Move teslemetry time-of-use URL out of strings.json

Co-authored-by: Robert Resch <robert@resch.dev>
Co-authored-by: Franck Nijhof <frenck@frenck.nl>

.github/workflows/builder.yml

@@ -14,7 +14,9 @@ env:
   PIP_TIMEOUT: 60
   UV_HTTP_TIMEOUT: 60
   UV_SYSTEM_PYTHON: "true"
-  BASE_IMAGE_VERSION: "2025.11.0"
+  # Base image version from https://github.com/home-assistant/docker
+  BASE_IMAGE_VERSION: "2025.11.3"
+  ARCHITECTURES: '["amd64", "aarch64"]'
 
 jobs:
   init:
@@ -25,9 +27,10 @@ jobs:
       version: ${{ steps.version.outputs.version }}
       channel: ${{ steps.version.outputs.channel }}
       publish: ${{ steps.version.outputs.publish }}
+      architectures: ${{ env.ARCHITECTURES }}
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
@@ -85,7 +88,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        arch: ["amd64", "aarch64"]
+        arch: ${{ fromJson(needs.init.outputs.architectures) }}
         include:
           - arch: amd64
             os: ubuntu-latest
@@ -93,7 +96,7 @@ jobs:
             os: ubuntu-24.04-arm
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Download nightly wheels of frontend
         if: needs.init.outputs.channel == 'dev'
@@ -187,7 +190,8 @@ jobs:
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Install Cosign
+      - &install_cosign
+        name: Install Cosign
         uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
         with:
           cosign-release: "v2.5.3"
@@ -269,7 +273,7 @@ jobs:
           - green
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set build additional args
         run: |
@@ -291,7 +295,7 @@ jobs:
 
       # home-assistant/builder doesn't support sha pinning
       - name: Build base image
-        uses: home-assistant/builder@2025.09.0
+        uses: home-assistant/builder@2025.11.0
         with:
           args: |
             $BUILD_ARGS \
@@ -307,7 +311,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize git
         uses: home-assistant/actions/helpers/git-init@master
@@ -350,13 +354,7 @@ jobs:
       matrix:
         registry: ["ghcr.io/home-assistant", "docker.io/homeassistant"]
     steps:
-      - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
-
-      - name: Install Cosign
-        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
-        with:
-          cosign-release: "v2.2.3"
+      - *install_cosign
 
       - name: Login to DockerHub
         if: matrix.registry == 'docker.io/homeassistant'
@@ -366,88 +364,104 @@ jobs:
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
-        if: matrix.registry == 'ghcr.io/home-assistant'
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0
         with:
           registry: ghcr.io
           username: ${{ github.repository_owner }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Build Meta Image
+      - name: Verify architecture image signatures
         shell: bash
         run: |
-          export DOCKER_CLI_EXPERIMENTAL=enabled
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
+          for arch in $ARCHS; do
+            echo "Verifying ${arch} image signature..."
+            cosign verify \
+              --certificate-oidc-issuer https://token.actions.githubusercontent.com \
+              --certificate-identity-regexp https://github.com/home-assistant/core/.* \
+              "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
+          done
+          echo "✓ All images verified successfully"
 
-          function create_manifest() {
-            local tag_l=${1}
-            local tag_r=${2}
-            local registry=${{ matrix.registry }}
+      # Generate all Docker tags based on version string
+      # Version format: YYYY.MM.PATCH, YYYY.MM.PATCHbN (beta), or YYYY.MM.PATCH.devYYYYMMDDHHMM (dev)
+      # Examples:
+      #   2025.12.1     (stable)    -> tags: 2025.12.1, 2025.12, stable, latest, beta, rc
+      #   2025.12.0b3   (beta)      -> tags: 2025.12.0b3, beta, rc
+      #   2025.12.0.dev202511250240 -> tags: 2025.12.0.dev202511250240, dev
+      - name: Generate Docker metadata
+        id: meta
+        uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5.10.0
+        with:
+          images: ${{ matrix.registry }}/home-assistant
+          sep-tags: ","
+          tags: |
+            type=raw,value=${{ needs.init.outputs.version }},priority=9999
+            type=raw,value=dev,enable=${{ contains(needs.init.outputs.version, 'd') }}
+            type=raw,value=beta,enable=${{ !contains(needs.init.outputs.version, 'd') }}
+            type=raw,value=rc,enable=${{ !contains(needs.init.outputs.version, 'd') }}
+            type=raw,value=stable,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
+            type=raw,value=latest,enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
+            type=semver,pattern={{major}}.{{minor}},value=${{ needs.init.outputs.version }},enable=${{ !contains(needs.init.outputs.version, 'd') && !contains(needs.init.outputs.version, 'b') }}
 
-            docker manifest create "${registry}/home-assistant:${tag_l}" \
-              "${registry}/amd64-homeassistant:${tag_r}" \
-              "${registry}/aarch64-homeassistant:${tag_r}"
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@e468171a9de216ec08956ac3ada2f0791b6bd435 # v3.7.1
 
-            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
-              "${registry}/amd64-homeassistant:${tag_r}" \
-              --os linux --arch amd64
+      - name: Copy architecture images to DockerHub
+        if: matrix.registry == 'docker.io/homeassistant'
+        shell: bash
+        run: |
+          # Use imagetools to copy image blobs directly between registries
+          # This preserves provenance/attestations and seems to be much faster than pull/push
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
+          for arch in $ARCHS; do
+            echo "Copying ${arch} image to DockerHub..."
+            for attempt in 1 2 3; do
+              if docker buildx imagetools create \
+                --tag "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}" \
+                "ghcr.io/home-assistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"; then
+                break
+              fi
+              echo "Attempt ${attempt} failed, retrying in 10 seconds..."
+              sleep 10
+              if [ "${attempt}" -eq 3 ]; then
+                echo "Failed after 3 attempts"
+                exit 1
+              fi
+            done
+            cosign sign --yes "docker.io/homeassistant/${arch}-homeassistant:${{ needs.init.outputs.version }}"
+          done
 
-            docker manifest annotate "${registry}/home-assistant:${tag_l}" \
-              "${registry}/aarch64-homeassistant:${tag_r}" \
-              --os linux --arch arm64 --variant=v8
+      - name: Create and push multi-arch manifests
+        shell: bash
+        run: |
+          # Build list of architecture images dynamically
+          ARCHS=$(echo '${{ needs.init.outputs.architectures }}' | jq -r '.[]')
+          ARCH_IMAGES=()
+          for arch in $ARCHS; do
+            ARCH_IMAGES+=("${{ matrix.registry }}/${arch}-homeassistant:${{ needs.init.outputs.version }}")
+          done
 
-            docker manifest push --purge "${registry}/home-assistant:${tag_l}"
-            cosign sign --yes "${registry}/home-assistant:${tag_l}"
-          }
+          # Build list of all tags for single manifest creation
+          # Note: Using sep-tags=',' in metadata-action for easier parsing
+          TAG_ARGS=()
+          IFS=',' read -ra TAGS <<< "${{ steps.meta.outputs.tags }}"
+          for tag in "${TAGS[@]}"; do
+            TAG_ARGS+=("--tag" "${tag}")
+          done
 
-          function validate_image() {
-            local image=${1}
-            if ! cosign verify --certificate-oidc-issuer https://token.actions.githubusercontent.com --certificate-identity-regexp https://github.com/home-assistant/core/.* "${image}"; then
-              echo "Invalid signature!"
-              exit 1
-            fi
-          }
+          # Create manifest with ALL tags in a single operation (much faster!)
+          echo "Creating multi-arch manifest with tags: ${TAGS[*]}"
+          docker buildx imagetools create "${TAG_ARGS[@]}" "${ARCH_IMAGES[@]}"
 
-          function push_dockerhub() {
-            local image=${1}
-            local tag=${2}
+          # Sign each tag separately (signing requires individual tag names)
+          echo "Signing all tags..."
+          for tag in "${TAGS[@]}"; do
+            echo "Signing ${tag}"
+            cosign sign --yes "${tag}"
+          done
 
-            docker tag "ghcr.io/home-assistant/${image}:${tag}" "docker.io/homeassistant/${image}:${tag}"
-            docker push "docker.io/homeassistant/${image}:${tag}"
-            cosign sign --yes "docker.io/homeassistant/${image}:${tag}"
-          }
-
-          # Pull images from github container registry and verify signature
-          docker pull "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
-          docker pull "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
-
-          validate_image "ghcr.io/home-assistant/amd64-homeassistant:${{ needs.init.outputs.version }}"
-          validate_image "ghcr.io/home-assistant/aarch64-homeassistant:${{ needs.init.outputs.version }}"
-
-          if [[ "${{ matrix.registry }}" ==  "docker.io/homeassistant" ]]; then
-            # Upload images to dockerhub
-            push_dockerhub "amd64-homeassistant" "${{ needs.init.outputs.version }}"
-            push_dockerhub "aarch64-homeassistant" "${{ needs.init.outputs.version }}"
-          fi
-
-          # Create version tag
-          create_manifest "${{ needs.init.outputs.version }}" "${{ needs.init.outputs.version }}"
-
-          # Create general tags
-          if [[ "${{ needs.init.outputs.version }}" =~ d ]]; then
-            create_manifest "dev" "${{ needs.init.outputs.version }}"
-          elif [[ "${{ needs.init.outputs.version }}" =~ b ]]; then
-            create_manifest "beta" "${{ needs.init.outputs.version }}"
-            create_manifest "rc" "${{ needs.init.outputs.version }}"
-          else
-            create_manifest "stable" "${{ needs.init.outputs.version }}"
-            create_manifest "latest" "${{ needs.init.outputs.version }}"
-            create_manifest "beta" "${{ needs.init.outputs.version }}"
-            create_manifest "rc" "${{ needs.init.outputs.version }}"
-
-            # Create series version tag (e.g. 2021.6)
-            v="${{ needs.init.outputs.version }}"
-            create_manifest "${v%.*}" "${{ needs.init.outputs.version }}"
-          fi
+          echo "All manifests created and signed successfully"
 
   build_python:
     name: Build PyPi package
@@ -460,7 +474,7 @@ jobs:
     if: github.repository_owner == 'home-assistant' && needs.init.outputs.publish == 'true'
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0
@@ -505,7 +519,7 @@ jobs:
       HASSFEST_IMAGE_TAG: ghcr.io/home-assistant/hassfest:${{ needs.init.outputs.version }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Login to GitHub Container Registry
         uses: docker/login-action@5e57cd118135c172c3672efd75eb46360885c0ef # v3.6.0

.github/workflows/ci.yaml

@@ -40,9 +40,9 @@ env:
   CACHE_VERSION: 2
   UV_CACHE_VERSION: 1
   MYPY_CACHE_VERSION: 1
-  HA_SHORT_VERSION: "2025.12"
-  DEFAULT_PYTHON: "3.13"
-  ALL_PYTHON_VERSIONS: "['3.13', '3.14']"
+  HA_SHORT_VERSION: "2026.1"
+  DEFAULT_PYTHON: "3.13.9"
+  ALL_PYTHON_VERSIONS: "['3.13.9', '3.14.0']"
   # 10.3 is the oldest supported version
   # - 10.3.32 is the version currently shipped with Synology (as of 17 Feb 2022)
   # 10.6 is the current long-term-support
@@ -99,7 +99,7 @@ jobs:
     steps:
       - &checkout
         name: Check out code from GitHub
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
       - name: Generate partial Python venv restore key
         id: generate_python_cache_key
         run: |

.github/workflows/codeql.yml

@@ -21,14 +21,14 @@ jobs:
 
     steps:
       - name: Check out code from GitHub
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
+        uses: github/codeql-action/init@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
         with:
           languages: python
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
+        uses: github/codeql-action/analyze@fe4161a26a8629af62121b670040955b330f9af2 # v4.31.6
         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@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
+        uses: actions/ai-inference@334892bb203895caaed82ec52d23c1ed9385151e # v2.0.4
         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@5022b33bc1431add9b2831934daf8147a2ad9331 # v2.0.2
+        uses: actions/ai-inference@334892bb203895caaed82ec52d23c1ed9385151e # v2.0.4
         with:
           model: openai/gpt-4o-mini
           system-prompt: |

.github/workflows/stale.yml

@@ -17,7 +17,7 @@ jobs:
       # - No PRs marked as no-stale
       # - No issues (-1)
       - name: 60 days stale PRs policy
-        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           days-before-stale: 60
@@ -57,7 +57,7 @@ jobs:
       # - No issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: 90 days stale issues
-        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ steps.token.outputs.token }}
           days-before-stale: 90
@@ -87,7 +87,7 @@ jobs:
       # - No Issues marked as no-stale or help-wanted
       # - No PRs (-1)
       - name: Needs more information stale issues policy
-        uses: actions/stale@5f858e3efba33a5ca4407a664cc011ad407f2008 # v10.1.0
+        uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
         with:
           repo-token: ${{ steps.token.outputs.token }}
           only-labels: "needs-more-information"

.github/workflows/translations.yml

@@ -19,7 +19,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0

.github/workflows/wheels.yml

@@ -31,7 +31,7 @@ jobs:
     steps:
       - &checkout
         name: Checkout the repository
-        uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
 
       - name: Set up Python ${{ env.DEFAULT_PYTHON }}
         id: python
@@ -136,7 +136,7 @@ jobs:
           sed -i "/uv/d" requirements_diff.txt
 
       - name: Build wheels
-        uses: &home-assistant-wheels home-assistant/wheels@6066c17a2a4aafcf7bdfeae01717f63adfcdba98 # 2025.11.0
+        uses: &home-assistant-wheels home-assistant/wheels@e5742a69d69f0e274e2689c998900c7d19652c21 # 2025.12.0
         with:
           abi: ${{ matrix.abi }}
           tag: musllinux_1_2

.strict-typing

@@ -187,6 +187,7 @@ homeassistant.components.elkm1.*
 homeassistant.components.emulated_hue.*
 homeassistant.components.energenie_power_sockets.*
 homeassistant.components.energy.*
+homeassistant.components.energyid.*
 homeassistant.components.energyzero.*
 homeassistant.components.enigma2.*
 homeassistant.components.enphase_envoy.*

CODEOWNERS

@@ -452,6 +452,8 @@ build.json @home-assistant/supervisor
 /tests/components/energenie_power_sockets/ @gnumpi
 /homeassistant/components/energy/ @home-assistant/core
 /tests/components/energy/ @home-assistant/core
+/homeassistant/components/energyid/ @JrtPec @Molier
+/tests/components/energyid/ @JrtPec @Molier
 /homeassistant/components/energyzero/ @klaasnicolaas
 /tests/components/energyzero/ @klaasnicolaas
 /homeassistant/components/enigma2/ @autinerd
@@ -537,6 +539,8 @@ build.json @home-assistant/supervisor
 /tests/components/freebox/ @hacf-fr @Quentame
 /homeassistant/components/freedompro/ @stefano055415
 /tests/components/freedompro/ @stefano055415
+/homeassistant/components/fressnapf_tracker/ @eifinger
+/tests/components/fressnapf_tracker/ @eifinger
 /homeassistant/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /tests/components/fritz/ @AaronDavidSchneider @chemelli74 @mib1185
 /homeassistant/components/fritzbox/ @mib1185 @flabbamann
@@ -1759,6 +1763,7 @@ build.json @home-assistant/supervisor
 /homeassistant/components/vilfo/ @ManneW
 /tests/components/vilfo/ @ManneW
 /homeassistant/components/vivotek/ @HarlemSquirrel
+/tests/components/vivotek/ @HarlemSquirrel
 /homeassistant/components/vizio/ @raman325
 /tests/components/vizio/ @raman325
 /homeassistant/components/vlc_telnet/ @rodripf @MartinHjelmare

Dockerfile.dev

@@ -35,25 +35,22 @@ COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
 
 USER vscode
 
-COPY .python-version ./
-RUN uv python install
-
 ENV VIRTUAL_ENV="/home/vscode/.local/ha-venv"
-RUN uv venv $VIRTUAL_ENV
+RUN --mount=type=bind,source=.python-version,target=.python-version \
+    uv python install \
+    && uv venv $VIRTUAL_ENV
 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
-RUN uv pip install -r requirements.txt
-COPY requirements_test.txt requirements_test_pre_commit.txt ./
-RUN uv pip install -r requirements_test.txt
+RUN --mount=type=bind,source=requirements.txt,target=requirements.txt \
+    --mount=type=bind,source=homeassistant/package_constraints.txt,target=homeassistant/package_constraints.txt \
+    --mount=type=bind,source=requirements_test.txt,target=requirements_test.txt \
+    --mount=type=bind,source=requirements_test_pre_commit.txt,target=requirements_test_pre_commit.txt \
+    uv pip install -r requirements.txt -r requirements_test.txt
 
 WORKDIR /workspaces
 

homeassistant/auth/permissions/events.py

@@ -7,6 +7,7 @@ from typing import Any, Final
 from homeassistant.const import (
     EVENT_COMPONENT_LOADED,
     EVENT_CORE_CONFIG_UPDATE,
+    EVENT_LABS_UPDATED,
     EVENT_LOVELACE_UPDATED,
     EVENT_PANELS_UPDATED,
     EVENT_RECORDER_5MIN_STATISTICS_GENERATED,
@@ -45,6 +46,7 @@ SUBSCRIBE_ALLOWLIST: Final[set[EventType[Any] | str]] = {
     EVENT_STATE_CHANGED,
     EVENT_THEMES_UPDATED,
     EVENT_LABEL_REGISTRY_UPDATED,
+    EVENT_LABS_UPDATED,
     EVENT_CATEGORY_REGISTRY_UPDATED,
     EVENT_FLOOR_REGISTRY_UPDATED,
 }

homeassistant/bootstrap.py

@@ -1000,7 +1000,7 @@ class _WatchPendingSetups:
             # We log every LOG_SLOW_STARTUP_INTERVAL until all integrations are done
             # once we take over LOG_SLOW_STARTUP_INTERVAL (60s) to start up
             _LOGGER.warning(
-                "Waiting on integrations to complete setup: %s",
+                "Waiting for integrations to complete setup: %s",
                 self._setup_started,
             )
 

homeassistant/components/airobot/config_flow.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Mapping
 from dataclasses import dataclass
 import logging
 from typing import Any
@@ -174,6 +175,56 @@ class AirobotConfigFlow(BaseConfigFlow, domain=DOMAIN):
             step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
         )
 
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication upon an API authentication error."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm reauthentication dialog."""
+        errors: dict[str, str] = {}
+        reauth_entry = self._get_reauth_entry()
+
+        if user_input is not None:
+            # Combine existing data with new password
+            data = {
+                CONF_HOST: reauth_entry.data[CONF_HOST],
+                CONF_USERNAME: reauth_entry.data[CONF_USERNAME],
+                CONF_PASSWORD: user_input[CONF_PASSWORD],
+            }
+
+            try:
+                await validate_input(self.hass, data)
+            except CannotConnect:
+                errors["base"] = "cannot_connect"
+            except InvalidAuth:
+                errors["base"] = "invalid_auth"
+            except Exception:
+                _LOGGER.exception("Unexpected exception")
+                errors["base"] = "unknown"
+            else:
+                return self.async_update_reload_and_abort(
+                    reauth_entry,
+                    data_updates={CONF_PASSWORD: user_input[CONF_PASSWORD]},
+                )
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PASSWORD): str,
+                }
+            ),
+            description_placeholders={
+                "username": reauth_entry.data[CONF_USERNAME],
+                "host": reauth_entry.data[CONF_HOST],
+            },
+            errors=errors,
+        )
+
 
 class CannotConnect(HomeAssistantError):
     """Error to indicate we cannot connect."""

homeassistant/components/airobot/coordinator.py

@@ -11,6 +11,7 @@ from pyairobotrest.exceptions import AirobotAuthError, AirobotConnectionError
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
 from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import ConfigEntryAuthFailed
 from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
 
@@ -53,7 +54,15 @@ class AirobotDataUpdateCoordinator(DataUpdateCoordinator[AirobotData]):
         try:
             status = await self.client.get_statuses()
             settings = await self.client.get_settings()
-        except (AirobotAuthError, AirobotConnectionError) as err:
-            raise UpdateFailed(f"Failed to communicate with device: {err}") from err
+        except AirobotAuthError as err:
+            raise ConfigEntryAuthFailed(
+                translation_domain=DOMAIN,
+                translation_key="authentication_failed",
+            ) from err
+        except AirobotConnectionError as err:
+            raise UpdateFailed(
+                translation_domain=DOMAIN,
+                translation_key="connection_failed",
+            ) from err
 
         return AirobotData(status=status, settings=settings)

homeassistant/components/airobot/manifest.json

@@ -12,6 +12,6 @@
   "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["pyairobotrest"],
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
   "requirements": ["pyairobotrest==0.1.0"]
 }

homeassistant/components/airobot/quality_scale.yaml

@@ -34,7 +34,7 @@ rules:
   integration-owner: done
   log-when-unavailable: done
   parallel-updates: done
-  reauthentication-flow: todo
+  reauthentication-flow: done
   test-coverage: done
 
   # Gold

homeassistant/components/airobot/strings.json

@@ -1,7 +1,8 @@
 {
   "config": {
     "abort": {
-      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]"
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]"
     },
     "error": {
       "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
@@ -14,15 +15,24 @@
           "password": "[%key:common::config_flow::data::password%]"
         },
         "data_description": {
-          "password": "The thermostat password."
+          "password": "[%key:component::airobot::config::step::user::data_description::password%]"
         },
         "description": "Airobot thermostat {device_id} discovered at {host}. Enter the password to complete setup. Find the password in the thermostat settings menu under Connectivity → Mobile app."
       },
+      "reauth_confirm": {
+        "data": {
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "password": "[%key:component::airobot::config::step::user::data_description::password%]"
+        },
+        "description": "The authentication for Airobot thermostat at {host} (Device ID: {username}) has expired. Please enter the password to reauthenticate. Find the password in the thermostat settings menu under Connectivity → Mobile app."
+      },
       "user": {
         "data": {
           "host": "[%key:common::config_flow::data::host%]",
           "password": "[%key:common::config_flow::data::password%]",
-          "username": "[%key:common::config_flow::data::username%]"
+          "username": "Device ID"
         },
         "data_description": {
           "host": "The hostname or IP address of your Airobot thermostat.",
@@ -34,6 +44,12 @@
     }
   },
   "exceptions": {
+    "authentication_failed": {
+      "message": "Authentication failed, please reauthenticate."
+    },
+    "connection_failed": {
+      "message": "Failed to communicate with device."
+    },
     "set_preset_mode_failed": {
       "message": "Failed to set preset mode to {preset_mode}."
     },

homeassistant/components/alarm_control_panel/strings.json

@@ -159,81 +159,74 @@
   "title": "Alarm control panel",
   "triggers": {
     "armed": {
-      "description": "Triggers when an alarm is armed.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed::description%]",
+      "description": "Triggers after one or more alarms become armed, regardless of the mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is armed"
+      "name": "Alarm armed"
     },
     "armed_away": {
-      "description": "Triggers when an alarm is armed away.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_away::description%]",
+      "description": "Triggers after one or more alarms become armed in away mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is armed away"
+      "name": "Alarm armed away"
     },
     "armed_home": {
-      "description": "Triggers when an alarm is armed home.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_home::description%]",
+      "description": "Triggers after one or more alarms become armed in home mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is armed home"
+      "name": "Alarm armed home"
     },
     "armed_night": {
-      "description": "Triggers when an alarm is armed night.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_night::description%]",
+      "description": "Triggers after one or more alarms become armed in night mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is armed night"
+      "name": "Alarm armed night"
     },
     "armed_vacation": {
-      "description": "Triggers when an alarm is armed vacation.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::armed_vacation::description%]",
+      "description": "Triggers after one or more alarms become armed in vacation mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is armed vacation"
+      "name": "Alarm armed vacation"
     },
     "disarmed": {
-      "description": "Triggers when an alarm is disarmed.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::disarmed::description%]",
+      "description": "Triggers after one or more alarms become disarmed.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is disarmed"
+      "name": "Alarm disarmed"
     },
     "triggered": {
-      "description": "Triggers when an alarm is triggered.",
-      "description_configured": "[%key:component::alarm_control_panel::triggers::triggered::description%]",
+      "description": "Triggers after one or more alarms become triggered.",
       "fields": {
         "behavior": {
           "description": "[%key:component::alarm_control_panel::common::trigger_behavior_description%]",
           "name": "[%key:component::alarm_control_panel::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an alarm is triggered"
+      "name": "Alarm triggered"
     }
   }
 }

homeassistant/components/alexa_devices/coordinator.py

@@ -21,7 +21,7 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, Upda
 
 from .const import _LOGGER, CONF_LOGIN_DATA, DOMAIN
 
-SCAN_INTERVAL = 30
+SCAN_INTERVAL = 300
 
 type AmazonConfigEntry = ConfigEntry[AmazonDevicesCoordinator]
 
@@ -45,7 +45,7 @@ class AmazonDevicesCoordinator(DataUpdateCoordinator[dict[str, AmazonDevice]]):
             config_entry=entry,
             update_interval=timedelta(seconds=SCAN_INTERVAL),
             request_refresh_debouncer=Debouncer(
-                hass, _LOGGER, cooldown=30, immediate=False
+                hass, _LOGGER, cooldown=SCAN_INTERVAL, immediate=False
             ),
         )
         self.api = AmazonEchoApi(

homeassistant/components/alexa_devices/manifest.json

@@ -8,5 +8,5 @@
   "iot_class": "cloud_polling",
   "loggers": ["aioamazondevices"],
   "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==9.0.3"]
+  "requirements": ["aioamazondevices==10.0.0"]
 }

homeassistant/components/anglian_water/__init__.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from aiohttp import CookieJar
 from pyanglianwater import AnglianWater
 from pyanglianwater.auth import MSOB2CAuth
 from pyanglianwater.exceptions import (
@@ -18,7 +19,7 @@ from homeassistant.const import (
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryError
-from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.aiohttp_client import async_create_clientsession
 
 from .const import CONF_ACCOUNT_NUMBER, DOMAIN
 from .coordinator import AnglianWaterConfigEntry, AnglianWaterUpdateCoordinator
@@ -33,7 +34,10 @@ async def async_setup_entry(
     auth = MSOB2CAuth(
         username=entry.data[CONF_USERNAME],
         password=entry.data[CONF_PASSWORD],
-        session=async_get_clientsession(hass),
+        session=async_create_clientsession(
+            hass,
+            cookie_jar=CookieJar(quote_cookie=False),
+        ),
         refresh_token=entry.data[CONF_ACCESS_TOKEN],
         account_number=entry.data[CONF_ACCOUNT_NUMBER],
     )

homeassistant/components/anglian_water/entity.py

@@ -18,17 +18,21 @@ _LOGGER = logging.getLogger(__name__)
 class AnglianWaterEntity(CoordinatorEntity[AnglianWaterUpdateCoordinator]):
     """Defines a Anglian Water entity."""
 
+    _attr_has_entity_name = True
+
     def __init__(
         self,
         coordinator: AnglianWaterUpdateCoordinator,
         smart_meter: SmartMeter,
+        key: str,
     ) -> None:
         """Initialize Anglian Water entity."""
         super().__init__(coordinator)
         self.smart_meter = smart_meter
+        self._attr_unique_id = f"{smart_meter.serial_number}_{key}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, smart_meter.serial_number)},
-            name="Smart Water Meter",
+            name=smart_meter.serial_number,
             manufacturer="Anglian Water",
             serial_number=smart_meter.serial_number,
         )

homeassistant/components/anglian_water/sensor.py

@@ -108,9 +108,8 @@ class AnglianWaterSensorEntity(AnglianWaterEntity, SensorEntity):
         description: AnglianWaterSensorEntityDescription,
     ) -> None:
         """Initialize Anglian Water sensor."""
-        super().__init__(coordinator, smart_meter)
+        super().__init__(coordinator, smart_meter, description.key)
         self.entity_description = description
-        self._attr_unique_id = f"{smart_meter.serial_number}_{description.key}"
 
     @property
     def native_value(self) -> float | None:

homeassistant/components/anglian_water/strings.json

@@ -19,7 +19,7 @@
         "data_description": {
           "account_number": "Your account number found on your latest bill.",
           "password": "Your password",
-          "username": "Username or email used to login to the Anglian Water website."
+          "username": "Username or email used to log in to the Anglian Water website."
         },
         "description": "Enter your Anglian Water account credentials to connect to Home Assistant."
       }

homeassistant/components/anthropic/__init__.py

@@ -17,7 +17,7 @@ from homeassistant.helpers import (
 )
 from homeassistant.helpers.typing import ConfigType
 
-from .const import CONF_CHAT_MODEL, DEFAULT, DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
+from .const import DEFAULT_CONVERSATION_NAME, DOMAIN, LOGGER
 
 PLATFORMS = (Platform.AI_TASK, Platform.CONVERSATION)
 CONFIG_SCHEMA = cv.config_entry_only_config_schema(DOMAIN)
@@ -37,14 +37,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: AnthropicConfigEntry) ->
         partial(anthropic.AsyncAnthropic, api_key=entry.data[CONF_API_KEY])
     )
     try:
-        # Use model from first conversation subentry for validation
-        subentries = list(entry.subentries.values())
-        if subentries:
-            model_id = subentries[0].data.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL])
-        else:
-            model_id = DEFAULT[CONF_CHAT_MODEL]
-        model = await client.models.retrieve(model_id=model_id, timeout=10.0)
-        LOGGER.debug("Anthropic model: %s", model.display_name)
+        await client.models.list(timeout=10.0)
     except anthropic.AuthenticationError as err:
         LOGGER.error("Invalid API key: %s", err)
         return False

homeassistant/components/anthropic/config_flow.py

@@ -421,6 +421,8 @@ class ConversationSubentryFlowHandler(ConfigSubentryFlow):
             )
             if short_form.search(model_alias):
                 model_alias += "-0"
+            if model_alias.endswith(("haiku", "opus", "sonnet")):
+                model_alias += "-latest"
             model_options.append(
                 SelectOptionDict(
                     label=model_info.display_name,

homeassistant/components/anthropic/entity.py

@@ -583,7 +583,7 @@ class AnthropicBaseLLMEntity(Entity):
             identifiers={(DOMAIN, subentry.subentry_id)},
             name=subentry.title,
             manufacturer="Anthropic",
-            model="Claude",
+            model=subentry.data.get(CONF_CHAT_MODEL, DEFAULT[CONF_CHAT_MODEL]),
             entry_type=dr.DeviceEntryType.SERVICE,
         )
 

homeassistant/components/anthropic/manifest.json

@@ -8,5 +8,5 @@
   "documentation": "https://www.home-assistant.io/integrations/anthropic",
   "integration_type": "service",
   "iot_class": "cloud_polling",
-  "requirements": ["anthropic==0.73.0"]
+  "requirements": ["anthropic==0.75.0"]
 }

homeassistant/components/apple_tv/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["zeroconf"],
   "documentation": "https://www.home-assistant.io/integrations/apple_tv",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["pyatv", "srptools"],
   "requirements": ["pyatv==0.16.1;python_version<'3.14'"],

homeassistant/components/assist_pipeline/pipeline.py

@@ -1123,63 +1123,6 @@ class PipelineRun:
         )
 
         try:
-            user_input = conversation.ConversationInput(
-                text=intent_input,
-                context=self.context,
-                conversation_id=conversation_id,
-                device_id=self._device_id,
-                satellite_id=self._satellite_id,
-                language=input_language,
-                agent_id=self.intent_agent.id,
-                extra_system_prompt=conversation_extra_system_prompt,
-            )
-
-            agent_id = self.intent_agent.id
-            processed_locally = agent_id == conversation.HOME_ASSISTANT_AGENT
-            all_targets_in_satellite_area = False
-            intent_response: intent.IntentResponse | None = None
-            if not processed_locally and not self._intent_agent_only:
-                # Sentence triggers override conversation agent
-                if (
-                    trigger_response_text
-                    := await conversation.async_handle_sentence_triggers(
-                        self.hass, user_input
-                    )
-                ) is not None:
-                    # Sentence trigger matched
-                    agent_id = "sentence_trigger"
-                    processed_locally = True
-                    intent_response = intent.IntentResponse(
-                        self.pipeline.conversation_language
-                    )
-                    intent_response.async_set_speech(trigger_response_text)
-
-                intent_filter: Callable[[RecognizeResult], bool] | None = None
-                # If the LLM has API access, we filter out some sentences that are
-                # interfering with LLM operation.
-                if (
-                    intent_agent_state := self.hass.states.get(self.intent_agent.id)
-                ) and intent_agent_state.attributes.get(
-                    ATTR_SUPPORTED_FEATURES, 0
-                ) & conversation.ConversationEntityFeature.CONTROL:
-                    intent_filter = _async_local_fallback_intent_filter
-
-                # Try local intents
-                if (
-                    intent_response is None
-                    and self.pipeline.prefer_local_intents
-                    and (
-                        intent_response := await conversation.async_handle_intents(
-                            self.hass,
-                            user_input,
-                            intent_filter=intent_filter,
-                        )
-                    )
-                ):
-                    # Local intent matched
-                    agent_id = conversation.HOME_ASSISTANT_AGENT
-                    processed_locally = True
-
             if self.tts_stream and self.tts_stream.supports_streaming_input:
                 tts_input_stream: asyncio.Queue[str | None] | None = asyncio.Queue()
             else:
@@ -1265,6 +1208,17 @@ class PipelineRun:
                 assert self.tts_stream is not None
                 self.tts_stream.async_set_message_stream(tts_input_stream_generator())
 
+            user_input = conversation.ConversationInput(
+                text=intent_input,
+                context=self.context,
+                conversation_id=conversation_id,
+                device_id=self._device_id,
+                satellite_id=self._satellite_id,
+                language=input_language,
+                agent_id=self.intent_agent.id,
+                extra_system_prompt=conversation_extra_system_prompt,
+            )
+
             with (
                 chat_session.async_get_chat_session(
                     self.hass, user_input.conversation_id
@@ -1276,6 +1230,53 @@ class PipelineRun:
                     chat_log_delta_listener=chat_log_delta_listener,
                 ) as chat_log,
             ):
+                agent_id = self.intent_agent.id
+                processed_locally = agent_id == conversation.HOME_ASSISTANT_AGENT
+                all_targets_in_satellite_area = False
+                intent_response: intent.IntentResponse | None = None
+                if not processed_locally and not self._intent_agent_only:
+                    # Sentence triggers override conversation agent
+                    if (
+                        trigger_response_text
+                        := await conversation.async_handle_sentence_triggers(
+                            self.hass, user_input, chat_log
+                        )
+                    ) is not None:
+                        # Sentence trigger matched
+                        agent_id = "sentence_trigger"
+                        processed_locally = True
+                        intent_response = intent.IntentResponse(
+                            self.pipeline.conversation_language
+                        )
+                        intent_response.async_set_speech(trigger_response_text)
+
+                    intent_filter: Callable[[RecognizeResult], bool] | None = None
+                    # If the LLM has API access, we filter out some sentences that are
+                    # interfering with LLM operation.
+                    if (
+                        intent_agent_state := self.hass.states.get(self.intent_agent.id)
+                    ) and intent_agent_state.attributes.get(
+                        ATTR_SUPPORTED_FEATURES, 0
+                    ) & conversation.ConversationEntityFeature.CONTROL:
+                        intent_filter = _async_local_fallback_intent_filter
+
+                    # Try local intents
+                    if (
+                        intent_response is None
+                        and self.pipeline.prefer_local_intents
+                        and (
+                            intent_response := await conversation.async_handle_intents(
+                                self.hass,
+                                user_input,
+                                chat_log,
+                                intent_filter=intent_filter,
+                            )
+                        )
+                    ):
+                        # Local intent matched
+                        agent_id = conversation.HOME_ASSISTANT_AGENT
+                        processed_locally = True
+
                 # It was already handled, create response and add to chat history
                 if intent_response is not None:
                     speech: str = intent_response.speech.get("plain", {}).get(

homeassistant/components/assist_satellite/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/assist_satellite",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.4.0"]
+  "requirements": ["hassil==3.5.0"]
 }

homeassistant/components/assist_satellite/strings.json

@@ -112,48 +112,44 @@
   "title": "Assist satellite",
   "triggers": {
     "idle": {
-      "description": "Triggers when an Assist satellite becomes idle.",
-      "description_configured": "[%key:component::assist_satellite::triggers::idle::description%]",
+      "description": "Triggers after one or more voice assistant satellites become idle after having processed a command.",
       "fields": {
         "behavior": {
           "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an Assist satellite becomes idle"
+      "name": "Satellite became idle"
     },
     "listening": {
-      "description": "Triggers when an Assist satellite starts listening.",
-      "description_configured": "[%key:component::assist_satellite::triggers::listening::description%]",
+      "description": "Triggers after one or more voice assistant satellites start listening for a command from someone.",
       "fields": {
         "behavior": {
           "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an Assist satellite starts listening"
+      "name": "Satellite started listening"
     },
     "processing": {
-      "description": "Triggers when an Assist satellite is processing.",
-      "description_configured": "[%key:component::assist_satellite::triggers::processing::description%]",
+      "description": "Triggers after one or more voice assistant satellites start processing a command after having heard it.",
       "fields": {
         "behavior": {
           "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an Assist satellite is processing"
+      "name": "Satellite started processing"
     },
     "responding": {
-      "description": "Triggers when an Assist satellite is responding.",
-      "description_configured": "[%key:component::assist_satellite::triggers::responding::description%]",
+      "description": "Triggers after one or more voice assistant satellites start responding to a command after having processed it, or start announcing something.",
       "fields": {
         "behavior": {
           "description": "[%key:component::assist_satellite::common::trigger_behavior_description%]",
           "name": "[%key:component::assist_satellite::common::trigger_behavior_name%]"
         }
       },
-      "name": "When an Assist satellite is responding"
+      "name": "Satellite started responding"
     }
   }
 }

homeassistant/components/automation/__init__.py

@@ -12,8 +12,9 @@ from typing import Any, Protocol, cast
 from propcache.api import cached_property
 import voluptuous as vol
 
-from homeassistant.components import websocket_api
+from homeassistant.components import labs, websocket_api
 from homeassistant.components.blueprint import CONF_USE_BLUEPRINT
+from homeassistant.components.labs import async_listen as async_labs_listen
 from homeassistant.const import (
     ATTR_ENTITY_ID,
     ATTR_MODE,
@@ -114,6 +115,52 @@ ATTR_SOURCE = "source"
 ATTR_VARIABLES = "variables"
 SERVICE_TRIGGER = "trigger"
 
+NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG = "new_triggers_conditions"
+
+_EXPERIMENTAL_CONDITION_PLATFORMS = {
+    "light",
+}
+
+_EXPERIMENTAL_TRIGGER_PLATFORMS = {
+    "alarm_control_panel",
+    "assist_satellite",
+    "binary_sensor",
+    "climate",
+    "cover",
+    "fan",
+    "lawn_mower",
+    "light",
+    "media_player",
+    "text",
+    "vacuum",
+}
+
+
+@callback
+def is_disabled_experimental_condition(hass: HomeAssistant, platform: str) -> bool:
+    """Check if the platform is a disabled experimental condition platform."""
+    return (
+        platform in _EXPERIMENTAL_CONDITION_PLATFORMS
+        and not labs.async_is_preview_feature_enabled(
+            hass,
+            DOMAIN,
+            NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG,
+        )
+    )
+
+
+@callback
+def is_disabled_experimental_trigger(hass: HomeAssistant, platform: str) -> bool:
+    """Check if the platform is a disabled experimental trigger platform."""
+    return (
+        platform in _EXPERIMENTAL_TRIGGER_PLATFORMS
+        and not labs.async_is_preview_feature_enabled(
+            hass,
+            DOMAIN,
+            NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG,
+        )
+    )
+
 
 class IfAction(Protocol):
     """Define the format of if_action."""
@@ -317,6 +364,20 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         schema=vol.Schema({vol.Optional(CONF_ID): str}),
     )
 
+    @callback
+    def new_triggers_conditions_listener() -> None:
+        """Handle new_triggers_conditions flag change."""
+        hass.async_create_task(
+            reload_helper.execute_service(ServiceCall(hass, DOMAIN, SERVICE_RELOAD))
+        )
+
+    async_labs_listen(
+        hass,
+        DOMAIN,
+        NEW_TRIGGERS_CONDITIONS_FEATURE_FLAG,
+        new_triggers_conditions_listener,
+    )
+
     websocket_api.async_register_command(hass, websocket_config)
 
     return True

homeassistant/components/automation/manifest.json

@@ -8,6 +8,8 @@
   "integration_type": "system",
   "preview_features": {
     "new_triggers_conditions": {
+      "feedback_url": "https://forms.gle/fWFZqf5MzuwWTsCH8",
+      "learn_more_url": "https://www.home-assistant.io/blog/2025/12/03/release-202512/#purpose-specific-triggers-and-conditions",
       "report_issue_url": "https://github.com/home-assistant/core/issues/new?template=bug_report.yml&integration_link=https://www.home-assistant.io/integrations/automation&integration_name=Automation"
     }
   },

homeassistant/components/automation/strings.json

@@ -69,10 +69,10 @@
   },
   "preview_features": {
     "new_triggers_conditions": {
-      "description": "Enables new intuitive triggers and conditions that are more user-friendly than technical state-based options.\n\nThese new automation features support targets across your entire home, letting you trigger automations for any entity, device, area, floor, or label (for example, when any light in your living room turned on). Integrations can now also provide their own intuitive triggers and conditions, just like actions.\n\nThis preview also includes a new tree view to help you navigate your home when adding triggers, conditions, and actions.",
-      "disable_confirmation": "Disabling this preview will cause automations and scripts that use the new intuitive triggers and conditions to fail.\n\nBefore disabling, ensure that your automations or scripts do not rely on this feature.",
-      "enable_confirmation": "This feature is still in development and may change. These new intuitive triggers and conditions are being refined based on user feedback and are not yet complete.\n\nBy enabling this preview, you'll have early access to these new capabilities, but be aware that they may be modified or updated in future releases.",
-      "name": "Intuitive triggers and conditions"
+      "description": "Enables new purpose-specific triggers and conditions that are more user-friendly than technical state-based options.\n\nThese new automation features support targets across your entire home, letting you trigger automations for any entity, device, area, floor, or label (for example, when any light in your living room turned on). Integrations can now also provide their own purpose-specific triggers and conditions, just like actions.\n\nThis preview also includes a new tree view to help you navigate your home when adding triggers, conditions, and actions.",
+      "disable_confirmation": "Disabling this preview will cause automations and scripts that use the new purpose-specific triggers and conditions to fail.\n\nBefore disabling, ensure that your automations or scripts do not rely on this feature.",
+      "enable_confirmation": "This feature is still in development and may change. These new purpose-specific triggers and conditions are being refined based on user feedback and are not yet complete.\n\nBy enabling this preview, you'll have early access to these new capabilities, but be aware that they may be modified or updated in future releases.",
+      "name": "Purpose-specific triggers and conditions"
     }
   },
   "services": {

homeassistant/components/bang_olufsen/__init__.py

@@ -21,29 +21,29 @@ from homeassistant.helpers import device_registry as dr
 from homeassistant.util.ssl import get_default_context
 
 from .const import DOMAIN
-from .websocket import BangOlufsenWebsocket
+from .websocket import BeoWebsocket
 
 
 @dataclass
-class BangOlufsenData:
+class BeoData:
     """Dataclass for API client and WebSocket client."""
 
-    websocket: BangOlufsenWebsocket
+    websocket: BeoWebsocket
     client: MozartClient
 
 
-type BangOlufsenConfigEntry = ConfigEntry[BangOlufsenData]
+type BeoConfigEntry = ConfigEntry[BeoData]
 
 PLATFORMS = [Platform.EVENT, Platform.MEDIA_PLAYER]
 
 
-async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry) -> bool:
+async def async_setup_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:
     """Set up from a config entry."""
 
     # Remove casts to str
     assert entry.unique_id
 
-    # Create device now as BangOlufsenWebsocket needs a device for debug logging, firing events etc.
+    # Create device now as BeoWebsocket needs a device for debug logging, firing events etc.
     device_registry = dr.async_get(hass)
     device_registry.async_get_or_create(
         config_entry_id=entry.entry_id,
@@ -68,10 +68,10 @@ async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry)
         await client.close_api_client()
         raise ConfigEntryNotReady(f"Unable to connect to {entry.title}") from error
 
-    websocket = BangOlufsenWebsocket(hass, entry, client)
+    websocket = BeoWebsocket(hass, entry, client)
 
     # Add the websocket and API client
-    entry.runtime_data = BangOlufsenData(websocket, client)
+    entry.runtime_data = BeoData(websocket, client)
 
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
 
@@ -82,9 +82,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: BangOlufsenConfigEntry)
     return True
 
 
-async def async_unload_entry(
-    hass: HomeAssistant, entry: BangOlufsenConfigEntry
-) -> bool:
+async def async_unload_entry(hass: HomeAssistant, entry: BeoConfigEntry) -> bool:
     """Unload a config entry."""
     # Close the API client and WebSocket notification listener
     entry.runtime_data.client.disconnect_notifications()

homeassistant/components/bang_olufsen/config_flow.py

@@ -47,7 +47,7 @@ _exception_map = {
 }
 
 
-class BangOlufsenConfigFlowHandler(ConfigFlow, domain=DOMAIN):
+class BeoConfigFlowHandler(ConfigFlow, domain=DOMAIN):
     """Handle a config flow."""
 
     _beolink_jid = ""

homeassistant/components/bang_olufsen/const.py

@@ -14,15 +14,19 @@ from homeassistant.components.media_player import (
 )
 
 
-class BangOlufsenSource:
+class BeoSource:
     """Class used for associating device source ids with friendly names. May not include all sources."""
 
+    DEEZER: Final[Source] = Source(name="Deezer", id="deezer")
     LINE_IN: Final[Source] = Source(name="Line-In", id="lineIn")
+    NET_RADIO: Final[Source] = Source(name="B&O Radio", id="netRadio")
     SPDIF: Final[Source] = Source(name="Optical", id="spdif")
+    TIDAL: Final[Source] = Source(name="Tidal", id="tidal")
+    UNKNOWN: Final[Source] = Source(name="Unknown Source", id="unknown")
     URI_STREAMER: Final[Source] = Source(name="Audio Streamer", id="uriStreamer")
 
 
-BANG_OLUFSEN_STATES: dict[str, MediaPlayerState] = {
+BEO_STATES: dict[str, MediaPlayerState] = {
     # Dict used for translating device states to Home Assistant states.
     "started": MediaPlayerState.PLAYING,
     "buffering": MediaPlayerState.PLAYING,
@@ -36,19 +40,19 @@ BANG_OLUFSEN_STATES: dict[str, MediaPlayerState] = {
 }
 
 # Dict used for translating Home Assistant settings to device repeat settings.
-BANG_OLUFSEN_REPEAT_FROM_HA: dict[RepeatMode, str] = {
+BEO_REPEAT_FROM_HA: dict[RepeatMode, str] = {
     RepeatMode.ALL: "all",
     RepeatMode.ONE: "track",
     RepeatMode.OFF: "none",
 }
 # Dict used for translating device repeat settings to Home Assistant settings.
-BANG_OLUFSEN_REPEAT_TO_HA: dict[str, RepeatMode] = {
-    value: key for key, value in BANG_OLUFSEN_REPEAT_FROM_HA.items()
+BEO_REPEAT_TO_HA: dict[str, RepeatMode] = {
+    value: key for key, value in BEO_REPEAT_FROM_HA.items()
 }
 
 
 # Media types for play_media
-class BangOlufsenMediaType(StrEnum):
+class BeoMediaType(StrEnum):
     """Bang & Olufsen specific media types."""
 
     FAVOURITE = "favourite"
@@ -59,7 +63,7 @@ class BangOlufsenMediaType(StrEnum):
     OVERLAY_TTS = "overlay_tts"
 
 
-class BangOlufsenModel(StrEnum):
+class BeoModel(StrEnum):
     """Enum for compatible model names."""
 
     # Mozart devices
@@ -78,8 +82,18 @@ class BangOlufsenModel(StrEnum):
     BEOREMOTE_ONE = "Beoremote One"
 
 
+class BeoAttribute(StrEnum):
+    """Enum for extra_state_attribute keys."""
+
+    BEOLINK = "beolink"
+    BEOLINK_PEERS = "peers"
+    BEOLINK_SELF = "self"
+    BEOLINK_LEADER = "leader"
+    BEOLINK_LISTENERS = "listeners"
+
+
 # Physical "buttons" on devices
-class BangOlufsenButtons(StrEnum):
+class BeoButtons(StrEnum):
     """Enum for device buttons."""
 
     BLUETOOTH = "Bluetooth"
@@ -126,7 +140,7 @@ class WebsocketNotification(StrEnum):
 DOMAIN: Final[str] = "bang_olufsen"
 
 # Default values for configuration.
-DEFAULT_MODEL: Final[str] = BangOlufsenModel.BEOSOUND_BALANCE
+DEFAULT_MODEL: Final[str] = BeoModel.BEOSOUND_BALANCE
 
 # Configuration.
 CONF_SERIAL_NUMBER: Final = "serial_number"
@@ -134,7 +148,7 @@ CONF_BEOLINK_JID: Final = "jid"
 
 # Models to choose from in manual configuration.
 SELECTABLE_MODELS: list[str] = [
-    model.value for model in BangOlufsenModel if model != BangOlufsenModel.BEOREMOTE_ONE
+    model.value for model in BeoModel if model != BeoModel.BEOREMOTE_ONE
 ]
 
 MANUFACTURER: Final[str] = "Bang & Olufsen"
@@ -146,15 +160,15 @@ ATTR_ITEM_NUMBER: Final[str] = "in"
 ATTR_FRIENDLY_NAME: Final[str] = "fn"
 
 # Power states.
-BANG_OLUFSEN_ON: Final[str] = "on"
+BEO_ON: Final[str] = "on"
 
 VALID_MEDIA_TYPES: Final[tuple] = (
-    BangOlufsenMediaType.FAVOURITE,
-    BangOlufsenMediaType.DEEZER,
-    BangOlufsenMediaType.RADIO,
-    BangOlufsenMediaType.TTS,
-    BangOlufsenMediaType.TIDAL,
-    BangOlufsenMediaType.OVERLAY_TTS,
+    BeoMediaType.FAVOURITE,
+    BeoMediaType.DEEZER,
+    BeoMediaType.RADIO,
+    BeoMediaType.TTS,
+    BeoMediaType.TIDAL,
+    BeoMediaType.OVERLAY_TTS,
     MediaType.MUSIC,
     MediaType.URL,
     MediaType.CHANNEL,
@@ -232,7 +246,7 @@ FALLBACK_SOURCES: Final[SourceArray] = SourceArray(
 )
 
 # Device events
-BANG_OLUFSEN_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"
+BEO_WEBSOCKET_EVENT: Final[str] = f"{DOMAIN}_websocket_event"
 
 # Dict used to translate native Bang & Olufsen event names to string.json compatible ones
 EVENT_TRANSLATION_MAP: dict[str, str] = {
@@ -249,7 +263,7 @@ EVENT_TRANSLATION_MAP: dict[str, str] = {
 
 CONNECTION_STATUS: Final[str] = "CONNECTION_STATUS"
 
-DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BangOlufsenButtons]
+DEVICE_BUTTONS: Final[list[str]] = [x.value for x in BeoButtons]
 
 
 DEVICE_BUTTON_EVENTS: Final[list[str]] = [

homeassistant/components/bang_olufsen/diagnostics.py

@@ -10,13 +10,13 @@ from homeassistant.const import CONF_MODEL
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import DOMAIN
 from .util import get_device_buttons
 
 
 async def async_get_config_entry_diagnostics(
-    hass: HomeAssistant, config_entry: BangOlufsenConfigEntry
+    hass: HomeAssistant, config_entry: BeoConfigEntry
 ) -> dict[str, Any]:
     """Return diagnostics for a config entry."""
 

homeassistant/components/bang_olufsen/entity.py

@@ -24,8 +24,8 @@ from homeassistant.helpers.entity import Entity
 from .const import DOMAIN
 
 
-class BangOlufsenBase:
-    """Base class for BangOlufsen Home Assistant objects."""
+class BeoBase:
+    """Base class for Bang & Olufsen Home Assistant objects."""
 
     def __init__(self, entry: ConfigEntry, client: MozartClient) -> None:
         """Initialize the object."""
@@ -51,8 +51,8 @@ class BangOlufsenBase:
         )
 
 
-class BangOlufsenEntity(Entity, BangOlufsenBase):
-    """Base Entity for BangOlufsen entities."""
+class BeoEntity(Entity, BeoBase):
+    """Base Entity for Bang & Olufsen entities."""
 
     _attr_has_entity_name = True
     _attr_should_poll = False

homeassistant/components/bang_olufsen/event.py

@@ -14,7 +14,7 @@ from homeassistant.helpers.device_registry import DeviceInfo
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import (
     BEO_REMOTE_CONTROL_KEYS,
     BEO_REMOTE_KEY_EVENTS,
@@ -25,10 +25,10 @@ from .const import (
     DEVICE_BUTTON_EVENTS,
     DOMAIN,
     MANUFACTURER,
-    BangOlufsenModel,
+    BeoModel,
     WebsocketNotification,
 )
-from .entity import BangOlufsenEntity
+from .entity import BeoEntity
 from .util import get_device_buttons, get_remotes
 
 PARALLEL_UPDATES = 0
@@ -36,14 +36,14 @@ PARALLEL_UPDATES = 0
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: BangOlufsenConfigEntry,
+    config_entry: BeoConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up Event entities from config entry."""
-    entities: list[BangOlufsenEvent] = []
+    entities: list[BeoEvent] = []
 
     async_add_entities(
-        BangOlufsenButtonEvent(config_entry, button_type)
+        BeoButtonEvent(config_entry, button_type)
         for button_type in get_device_buttons(config_entry.data[CONF_MODEL])
     )
 
@@ -54,7 +54,7 @@ async def async_setup_entry(
         # Add Light keys
         entities.extend(
             [
-                BangOlufsenRemoteKeyEvent(
+                BeoRemoteKeyEvent(
                     config_entry,
                     remote,
                     f"{BEO_REMOTE_SUBMENU_LIGHT}/{key_type}",
@@ -66,7 +66,7 @@ async def async_setup_entry(
         # Add Control keys
         entities.extend(
             [
-                BangOlufsenRemoteKeyEvent(
+                BeoRemoteKeyEvent(
                     config_entry,
                     remote,
                     f"{BEO_REMOTE_SUBMENU_CONTROL}/{key_type}",
@@ -84,10 +84,9 @@ async def async_setup_entry(
         config_entry.entry_id
     )
     for device in devices:
-        if (
-            device.model == BangOlufsenModel.BEOREMOTE_ONE
-            and device.serial_number not in {remote.serial_number for remote in remotes}
-        ):
+        if device.model == BeoModel.BEOREMOTE_ONE and device.serial_number not in {
+            remote.serial_number for remote in remotes
+        }:
             device_registry.async_update_device(
                 device.id, remove_config_entry_id=config_entry.entry_id
             )
@@ -95,13 +94,13 @@ async def async_setup_entry(
     async_add_entities(new_entities=entities)
 
 
-class BangOlufsenEvent(BangOlufsenEntity, EventEntity):
+class BeoEvent(BeoEntity, EventEntity):
     """Base Event class."""
 
     _attr_device_class = EventDeviceClass.BUTTON
     _attr_entity_registry_enabled_default = False
 
-    def __init__(self, config_entry: BangOlufsenConfigEntry) -> None:
+    def __init__(self, config_entry: BeoConfigEntry) -> None:
         """Initialize Event."""
         super().__init__(config_entry, config_entry.runtime_data.client)
 
@@ -112,12 +111,12 @@ class BangOlufsenEvent(BangOlufsenEntity, EventEntity):
         self.async_write_ha_state()
 
 
-class BangOlufsenButtonEvent(BangOlufsenEvent):
+class BeoButtonEvent(BeoEvent):
     """Event class for Button events."""
 
     _attr_event_types = DEVICE_BUTTON_EVENTS
 
-    def __init__(self, config_entry: BangOlufsenConfigEntry, button_type: str) -> None:
+    def __init__(self, config_entry: BeoConfigEntry, button_type: str) -> None:
         """Initialize Button."""
         super().__init__(config_entry)
 
@@ -146,14 +145,14 @@ class BangOlufsenButtonEvent(BangOlufsenEvent):
         )
 
 
-class BangOlufsenRemoteKeyEvent(BangOlufsenEvent):
+class BeoRemoteKeyEvent(BeoEvent):
     """Event class for Beoremote One key events."""
 
     _attr_event_types = BEO_REMOTE_KEY_EVENTS
 
     def __init__(
         self,
-        config_entry: BangOlufsenConfigEntry,
+        config_entry: BeoConfigEntry,
         remote: PairedRemote,
         key_type: str,
     ) -> None:
@@ -166,8 +165,8 @@ class BangOlufsenRemoteKeyEvent(BangOlufsenEvent):
         self._attr_unique_id = f"{remote.serial_number}_{self._unique_id}_{key_type}"
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, f"{remote.serial_number}_{self._unique_id}")},
-            name=f"{BangOlufsenModel.BEOREMOTE_ONE}-{remote.serial_number}-{self._unique_id}",
-            model=BangOlufsenModel.BEOREMOTE_ONE,
+            name=f"{BeoModel.BEOREMOTE_ONE}-{remote.serial_number}-{self._unique_id}",
+            model=BeoModel.BEOREMOTE_ONE,
             serial_number=remote.serial_number,
             sw_version=remote.app_version,
             manufacturer=MANUFACTURER,

homeassistant/components/bang_olufsen/media_player.py

@@ -69,11 +69,11 @@ from homeassistant.helpers.entity_platform import (
 )
 from homeassistant.util.dt import utcnow
 
-from . import BangOlufsenConfigEntry
+from . import BeoConfigEntry
 from .const import (
-    BANG_OLUFSEN_REPEAT_FROM_HA,
-    BANG_OLUFSEN_REPEAT_TO_HA,
-    BANG_OLUFSEN_STATES,
+    BEO_REPEAT_FROM_HA,
+    BEO_REPEAT_TO_HA,
+    BEO_STATES,
     BEOLINK_JOIN_SOURCES,
     BEOLINK_JOIN_SOURCES_TO_UPPER,
     CONF_BEOLINK_JID,
@@ -82,11 +82,12 @@ from .const import (
     FALLBACK_SOURCES,
     MANUFACTURER,
     VALID_MEDIA_TYPES,
-    BangOlufsenMediaType,
-    BangOlufsenSource,
+    BeoAttribute,
+    BeoMediaType,
+    BeoSource,
     WebsocketNotification,
 )
-from .entity import BangOlufsenEntity
+from .entity import BeoEntity
 from .util import get_serial_number_from_jid
 
 PARALLEL_UPDATES = 0
@@ -95,7 +96,7 @@ SCAN_INTERVAL = timedelta(seconds=30)
 
 _LOGGER = logging.getLogger(__name__)
 
-BANG_OLUFSEN_FEATURES = (
+BEO_FEATURES = (
     MediaPlayerEntityFeature.BROWSE_MEDIA
     | MediaPlayerEntityFeature.CLEAR_PLAYLIST
     | MediaPlayerEntityFeature.GROUPING
@@ -118,15 +119,13 @@ BANG_OLUFSEN_FEATURES = (
 
 async def async_setup_entry(
     hass: HomeAssistant,
-    config_entry: BangOlufsenConfigEntry,
+    config_entry: BeoConfigEntry,
     async_add_entities: AddConfigEntryEntitiesCallback,
 ) -> None:
     """Set up a Media Player entity from config entry."""
     # Add MediaPlayer entity
     async_add_entities(
-        new_entities=[
-            BangOlufsenMediaPlayer(config_entry, config_entry.runtime_data.client)
-        ],
+        new_entities=[BeoMediaPlayer(config_entry, config_entry.runtime_data.client)],
         update_before_add=True,
     )
 
@@ -186,7 +185,7 @@ async def async_setup_entry(
     )
 
 
-class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
+class BeoMediaPlayer(BeoEntity, MediaPlayerEntity):
     """Representation of a media player."""
 
     _attr_name = None
@@ -224,7 +223,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         # Beolink compatible sources
         self._beolink_sources: dict[str, bool] = {}
         self._remote_leader: BeolinkLeader | None = None
-        # Extra state attributes for showing Beolink: peer(s), listener(s), leader and self
+        # Extra state attributes:
+        # Beolink: peer(s), listener(s), leader and self
         self._beolink_attributes: dict[str, dict[str, dict[str, str]]] = {}
 
     async def async_added_to_hass(self) -> None:
@@ -286,7 +286,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
             queue_settings = await self._client.get_settings_queue(_request_timeout=5)
 
             if queue_settings.repeat is not None:
-                self._attr_repeat = BANG_OLUFSEN_REPEAT_TO_HA[queue_settings.repeat]
+                self._attr_repeat = BEO_REPEAT_TO_HA[queue_settings.repeat]
 
             if queue_settings.shuffle is not None:
                 self._attr_shuffle = queue_settings.shuffle
@@ -406,8 +406,8 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # Check if source is line-in or optical and progress should be updated
         if self._source_change.id in (
-            BangOlufsenSource.LINE_IN.id,
-            BangOlufsenSource.SPDIF.id,
+            BeoSource.LINE_IN.id,
+            BeoSource.SPDIF.id,
         ):
             self._playback_progress = PlaybackProgress(progress=0)
 
@@ -436,7 +436,10 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         await self._async_update_beolink()
 
     async def _async_update_beolink(self) -> None:
-        """Update the current Beolink leader, listeners, peers and self."""
+        """Update the current Beolink leader, listeners, peers and self.
+
+        Updates Home Assistant state.
+        """
 
         self._beolink_attributes = {}
 
@@ -445,18 +448,22 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # Add Beolink self
         self._beolink_attributes = {
-            "beolink": {"self": {self.device_entry.name: self._beolink_jid}}
+            BeoAttribute.BEOLINK: {
+                BeoAttribute.BEOLINK_SELF: {self.device_entry.name: self._beolink_jid}
+            }
         }
 
         # Add Beolink peers
         peers = await self._client.get_beolink_peers()
 
         if len(peers) > 0:
-            self._beolink_attributes["beolink"]["peers"] = {}
+            self._beolink_attributes[BeoAttribute.BEOLINK][
+                BeoAttribute.BEOLINK_PEERS
+            ] = {}
             for peer in peers:
-                self._beolink_attributes["beolink"]["peers"][peer.friendly_name] = (
-                    peer.jid
-                )
+                self._beolink_attributes[BeoAttribute.BEOLINK][
+                    BeoAttribute.BEOLINK_PEERS
+                ][peer.friendly_name] = peer.jid
 
         # Add Beolink listeners / leader
         self._remote_leader = self._playback_metadata.remote_leader
@@ -477,7 +484,9 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
             # Add self
             group_members.append(self.entity_id)
 
-            self._beolink_attributes["beolink"]["leader"] = {
+            self._beolink_attributes[BeoAttribute.BEOLINK][
+                BeoAttribute.BEOLINK_LEADER
+            ] = {
                 self._remote_leader.friendly_name: self._remote_leader.jid,
             }
 
@@ -514,9 +523,9 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                                 beolink_listener.jid
                             )
                             break
-                self._beolink_attributes["beolink"]["listeners"] = (
-                    beolink_listeners_attribute
-                )
+                self._beolink_attributes[BeoAttribute.BEOLINK][
+                    BeoAttribute.BEOLINK_LISTENERS
+                ] = beolink_listeners_attribute
 
         self._attr_group_members = group_members
 
@@ -587,7 +596,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     @property
     def supported_features(self) -> MediaPlayerEntityFeature:
         """Flag media player features that are supported."""
-        features = BANG_OLUFSEN_FEATURES
+        features = BEO_FEATURES
 
         # Add seeking if supported by the current source
         if self._source_change.is_seekable is True:
@@ -598,7 +607,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     @property
     def state(self) -> MediaPlayerState:
         """Return the current state of the media player."""
-        return BANG_OLUFSEN_STATES[self._state]
+        return BEO_STATES[self._state]
 
     @property
     def volume_level(self) -> float | None:
@@ -615,11 +624,18 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         return None
 
     @property
-    def media_content_type(self) -> str:
+    def media_content_type(self) -> MediaType | str | None:
         """Return the current media type."""
-        # Hard to determine content type
-        if self._source_change.id == BangOlufsenSource.URI_STREAMER.id:
-            return MediaType.URL
+        content_type = {
+            BeoSource.URI_STREAMER.id: MediaType.URL,
+            BeoSource.DEEZER.id: BeoMediaType.DEEZER,
+            BeoSource.TIDAL.id: BeoMediaType.TIDAL,
+            BeoSource.NET_RADIO.id: BeoMediaType.RADIO,
+        }
+        # Hard to determine content type.
+        if self._source_change.id in content_type:
+            return content_type[self._source_change.id]
+
         return MediaType.MUSIC
 
     @property
@@ -632,6 +648,11 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
         """Return the current playback progress."""
         return self._playback_progress.progress
 
+    @property
+    def media_content_id(self) -> str | None:
+        """Return internal ID of Deezer, Tidal and radio stations."""
+        return self._playback_metadata.source_internal_id
+
     @property
     def media_image_url(self) -> str | None:
         """Return URL of the currently playing music."""
@@ -740,9 +761,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
     async def async_set_repeat(self, repeat: RepeatMode) -> None:
         """Set playback queues to repeat."""
         await self._client.set_settings_queue(
-            play_queue_settings=PlayQueueSettings(
-                repeat=BANG_OLUFSEN_REPEAT_FROM_HA[repeat]
-            )
+            play_queue_settings=PlayQueueSettings(repeat=BEO_REPEAT_FROM_HA[repeat])
         )
 
     async def async_set_shuffle(self, shuffle: bool) -> None:
@@ -846,7 +865,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                         self._volume.level.level + offset_volume, 100
                     )
 
-            if media_type == BangOlufsenMediaType.OVERLAY_TTS:
+            if media_type == BeoMediaType.OVERLAY_TTS:
                 # Bang & Olufsen cloud TTS
                 overlay_play_request.text_to_speech = (
                     OverlayPlayRequestTextToSpeechTextToSpeech(
@@ -863,14 +882,14 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
 
         # The "provider" media_type may not be suitable for overlay all the time.
         # Use it for now.
-        elif media_type == BangOlufsenMediaType.TTS:
+        elif media_type == BeoMediaType.TTS:
             await self._client.post_overlay_play(
                 overlay_play_request=OverlayPlayRequest(
                     uri=Uri(location=media_id),
                 )
             )
 
-        elif media_type == BangOlufsenMediaType.RADIO:
+        elif media_type == BeoMediaType.RADIO:
             await self._client.run_provided_scene(
                 scene_properties=SceneProperties(
                     action_list=[
@@ -882,13 +901,13 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
                 )
             )
 
-        elif media_type == BangOlufsenMediaType.FAVOURITE:
+        elif media_type == BeoMediaType.FAVOURITE:
             await self._client.activate_preset(id=int(media_id))
 
-        elif media_type in (BangOlufsenMediaType.DEEZER, BangOlufsenMediaType.TIDAL):
+        elif media_type in (BeoMediaType.DEEZER, BeoMediaType.TIDAL):
             try:
                 # Play Deezer flow.
-                if media_id == "flow" and media_type == BangOlufsenMediaType.DEEZER:
+                if media_id == "flow" and media_type == BeoMediaType.DEEZER:
                     deezer_id = None
 
                     if "id" in kwargs[ATTR_MEDIA_EXTRA]:

homeassistant/components/bang_olufsen/util.py

@@ -11,7 +11,7 @@ from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry as dr
 from homeassistant.helpers.device_registry import DeviceEntry
 
-from .const import DEVICE_BUTTONS, DOMAIN, BangOlufsenButtons, BangOlufsenModel
+from .const import DEVICE_BUTTONS, DOMAIN, BeoButtons, BeoModel
 
 
 def get_device(hass: HomeAssistant, unique_id: str) -> DeviceEntry:
@@ -40,16 +40,16 @@ async def get_remotes(client: MozartClient) -> list[PairedRemote]:
     ]
 
 
-def get_device_buttons(model: BangOlufsenModel) -> list[str]:
+def get_device_buttons(model: BeoModel) -> list[str]:
     """Get supported buttons for a given model."""
     buttons = DEVICE_BUTTONS.copy()
 
     # Beosound Premiere does not have a bluetooth button
-    if model == BangOlufsenModel.BEOSOUND_PREMIERE:
-        buttons.remove(BangOlufsenButtons.BLUETOOTH)
+    if model == BeoModel.BEOSOUND_PREMIERE:
+        buttons.remove(BeoButtons.BLUETOOTH)
 
     # Beoconnect Core does not have any buttons
-    elif model == BangOlufsenModel.BEOCONNECT_CORE:
+    elif model == BeoModel.BEOCONNECT_CORE:
         buttons = []
 
     return buttons

homeassistant/components/bang_olufsen/websocket.py

@@ -27,20 +27,20 @@ from homeassistant.helpers.dispatcher import async_dispatcher_send
 from homeassistant.util.enum import try_parse_enum
 
 from .const import (
-    BANG_OLUFSEN_WEBSOCKET_EVENT,
+    BEO_WEBSOCKET_EVENT,
     CONNECTION_STATUS,
     DOMAIN,
     EVENT_TRANSLATION_MAP,
-    BangOlufsenModel,
+    BeoModel,
     WebsocketNotification,
 )
-from .entity import BangOlufsenBase
+from .entity import BeoBase
 from .util import get_device, get_remotes
 
 _LOGGER = logging.getLogger(__name__)
 
 
-class BangOlufsenWebsocket(BangOlufsenBase):
+class BeoWebsocket(BeoBase):
     """The WebSocket listeners."""
 
     def __init__(
@@ -48,7 +48,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
     ) -> None:
         """Initialize the WebSocket listeners."""
 
-        BangOlufsenBase.__init__(self, entry, client)
+        BeoBase.__init__(self, entry, client)
 
         self.hass = hass
         self._device = get_device(hass, self._unique_id)
@@ -178,7 +178,7 @@ class BangOlufsenWebsocket(BangOlufsenBase):
                     self.entry.entry_id
                 )
                 if device.serial_number is not None
-                and device.model == BangOlufsenModel.BEOREMOTE_ONE
+                and device.model == BeoModel.BEOREMOTE_ONE
             ]
             # Get paired remotes from device
             remote_serial_numbers = [
@@ -274,4 +274,4 @@ class BangOlufsenWebsocket(BangOlufsenBase):
         }
 
         _LOGGER.debug("%s", debug_notification)
-        self.hass.bus.async_fire(BANG_OLUFSEN_WEBSOCKET_EVENT, debug_notification)
+        self.hass.bus.async_fire(BEO_WEBSOCKET_EVENT, debug_notification)

homeassistant/components/binary_sensor/icons.json

@@ -174,5 +174,13 @@
         "on": "mdi:window-open"
       }
     }
+  },
+  "triggers": {
+    "occupancy_cleared": {
+      "trigger": "mdi:home-outline"
+    },
+    "occupancy_detected": {
+      "trigger": "mdi:home"
+    }
   }
 }

homeassistant/components/binary_sensor/strings.json

@@ -1,4 +1,8 @@
 {
+  "common": {
+    "trigger_behavior_description_occupancy": "The behavior of the targeted occupancy sensors to trigger on.",
+    "trigger_behavior_name": "Behavior"
+  },
   "device_automation": {
     "condition_type": {
       "is_bat_low": "{entity_name} battery is low",
@@ -317,5 +321,36 @@
       }
     }
   },
-  "title": "Binary sensor"
+  "selector": {
+    "trigger_behavior": {
+      "options": {
+        "any": "Any",
+        "first": "First",
+        "last": "Last"
+      }
+    }
+  },
+  "title": "Binary sensor",
+  "triggers": {
+    "occupancy_cleared": {
+      "description": "Triggers after one or more occupancy sensors stop detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
+          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy cleared"
+    },
+    "occupancy_detected": {
+      "description": "Triggers after one or more occupancy sensors start detecting occupancy.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::binary_sensor::common::trigger_behavior_description_occupancy%]",
+          "name": "[%key:component::binary_sensor::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Occupancy detected"
+    }
+  }
 }

homeassistant/components/binary_sensor/trigger.py

@@ -0,0 +1,67 @@
+"""Provides triggers for binary sensors."""
+
+from homeassistant.const import STATE_OFF, STATE_ON
+from homeassistant.core import HomeAssistant
+from homeassistant.exceptions import HomeAssistantError
+from homeassistant.helpers.entity import get_device_class
+from homeassistant.helpers.trigger import EntityStateTriggerBase, Trigger
+from homeassistant.helpers.typing import UNDEFINED, UndefinedType
+
+from . import DOMAIN, BinarySensorDeviceClass
+
+
+def get_device_class_or_undefined(
+    hass: HomeAssistant, entity_id: str
+) -> str | None | UndefinedType:
+    """Get the device class of an entity or UNDEFINED if not found."""
+    try:
+        return get_device_class(hass, entity_id)
+    except HomeAssistantError:
+        return UNDEFINED
+
+
+class BinarySensorOnOffTrigger(EntityStateTriggerBase):
+    """Class for binary sensor on/off triggers."""
+
+    _device_class: BinarySensorDeviceClass | None
+    _domain: str = DOMAIN
+
+    def entity_filter(self, entities: set[str]) -> set[str]:
+        """Filter entities of this domain."""
+        entities = super().entity_filter(entities)
+        return {
+            entity_id
+            for entity_id in entities
+            if get_device_class_or_undefined(self._hass, entity_id)
+            == self._device_class
+        }
+
+
+def make_binary_sensor_trigger(
+    device_class: BinarySensorDeviceClass | None,
+    to_state: str,
+) -> type[BinarySensorOnOffTrigger]:
+    """Create an entity state trigger class."""
+
+    class CustomTrigger(BinarySensorOnOffTrigger):
+        """Trigger for entity state changes."""
+
+        _device_class = device_class
+        _to_state = to_state
+
+    return CustomTrigger
+
+
+TRIGGERS: dict[str, type[Trigger]] = {
+    "occupancy_detected": make_binary_sensor_trigger(
+        BinarySensorDeviceClass.OCCUPANCY, STATE_ON
+    ),
+    "occupancy_cleared": make_binary_sensor_trigger(
+        BinarySensorDeviceClass.OCCUPANCY, STATE_OFF
+    ),
+}
+
+
+async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
+    """Return the triggers for binary sensors."""
+    return TRIGGERS

homeassistant/components/binary_sensor/triggers.yaml

@@ -0,0 +1,25 @@
+.trigger_common_fields: &trigger_common_fields
+  behavior:
+    required: true
+    default: any
+    selector:
+      select:
+        translation_key: trigger_behavior
+        options:
+          - first
+          - last
+          - any
+
+occupancy_cleared:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      domain: binary_sensor
+      device_class: occupancy
+
+occupancy_detected:
+  fields: *trigger_common_fields
+  target:
+    entity:
+      domain: binary_sensor
+      device_class: occupancy

homeassistant/components/bluetooth/manifest.json

@@ -15,12 +15,12 @@
   ],
   "quality_scale": "internal",
   "requirements": [
-    "bleak==1.0.1",
+    "bleak==2.0.0",
     "bleak-retry-connector==4.4.3",
     "bluetooth-adapters==2.1.0",
     "bluetooth-auto-recovery==1.5.3",
     "bluetooth-data-tools==1.28.4",
     "dbus-fast==3.1.2",
-    "habluetooth==5.7.0"
+    "habluetooth==5.8.0"
   ]
 }

homeassistant/components/bosch_alarm/__init__.py

@@ -68,9 +68,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: BoschAlarmConfigEntry) -
         config_entry_id=entry.entry_id,
         connections={(CONNECTION_NETWORK_MAC, mac)} if mac else set(),
         identifiers={(DOMAIN, entry.unique_id or entry.entry_id)},
-        name=f"Bosch {panel.model}",
+        name=f"Bosch {panel.model.name}",
         manufacturer="Bosch Security Systems",
-        model=panel.model,
+        model=panel.model.name,
         sw_version=panel.firmware_version,
     )
     await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)

homeassistant/components/bosch_alarm/config_flow.py

@@ -83,7 +83,7 @@ async def try_connect(
     finally:
         await panel.disconnect()
 
-    return (panel.model, panel.serial_number)
+    return (panel.model.name, panel.serial_number)
 
 
 class BoschAlarmConfigFlow(ConfigFlow, domain=DOMAIN):

homeassistant/components/bosch_alarm/diagnostics.py

@@ -20,7 +20,8 @@ async def async_get_config_entry_diagnostics(
     return {
         "entry_data": async_redact_data(entry.data, TO_REDACT),
         "data": {
-            "model": entry.runtime_data.model,
+            "model": entry.runtime_data.model.name,
+            "family": entry.runtime_data.model.family.name,
             "serial_number": entry.runtime_data.serial_number,
             "protocol_version": entry.runtime_data.protocol_version,
             "firmware_version": entry.runtime_data.firmware_version,

homeassistant/components/bosch_alarm/entity.py

@@ -26,7 +26,7 @@ class BoschAlarmEntity(Entity):
         self._attr_should_poll = False
         self._attr_device_info = DeviceInfo(
             identifiers={(DOMAIN, unique_id)},
-            name=f"Bosch {panel.model}",
+            name=f"Bosch {panel.model.name}",
             manufacturer="Bosch Security Systems",
         )
 

homeassistant/components/bosch_alarm/manifest.json

@@ -12,5 +12,5 @@
   "integration_type": "device",
   "iot_class": "local_push",
   "quality_scale": "platinum",
-  "requirements": ["bosch-alarm-mode2==0.4.6"]
+  "requirements": ["bosch-alarm-mode2==0.4.10"]
 }

homeassistant/components/broadlink/manifest.json

@@ -36,6 +36,7 @@
     }
   ],
   "documentation": "https://www.home-assistant.io/integrations/broadlink",
+  "integration_type": "device",
   "iot_class": "local_polling",
   "loggers": ["broadlink"],
   "requirements": ["broadlink==0.19.0"]

homeassistant/components/camera/__init__.py

@@ -407,8 +407,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
         return [
             RTCIceServer(
                 urls=[
-                    "stun:stun.home-assistant.io:80",
                     "stun:stun.home-assistant.io:3478",
+                    "stun:stun.home-assistant.io:80",
                 ]
             ),
         ]

homeassistant/components/climate/icons.json

@@ -98,6 +98,12 @@
     }
   },
   "triggers": {
+    "started_cooling": {
+      "trigger": "mdi:snowflake"
+    },
+    "started_drying": {
+      "trigger": "mdi:water-percent"
+    },
     "started_heating": {
       "trigger": "mdi:fire"
     },

homeassistant/components/climate/strings.json

@@ -298,38 +298,55 @@
   },
   "title": "Climate",
   "triggers": {
-    "started_heating": {
-      "description": "Triggers when a climate starts to heat.",
-      "description_configured": "[%key:component::climate::triggers::started_heating::description%]",
+    "started_cooling": {
+      "description": "Triggers after one or more climate-control devices start cooling.",
       "fields": {
         "behavior": {
           "description": "[%key:component::climate::common::trigger_behavior_description%]",
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         }
       },
-      "name": "When a climate starts to heat"
+      "name": "Climate-control device started cooling"
+    },
+    "started_drying": {
+      "description": "Triggers after one or more climate-control devices start drying.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::common::trigger_behavior_description%]",
+          "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Climate-control device started drying"
+    },
+    "started_heating": {
+      "description": "Triggers after one or more climate-control devices start heating.",
+      "fields": {
+        "behavior": {
+          "description": "[%key:component::climate::common::trigger_behavior_description%]",
+          "name": "[%key:component::climate::common::trigger_behavior_name%]"
+        }
+      },
+      "name": "Climate-control device started heating"
     },
     "turned_off": {
-      "description": "Triggers when a climate is turned off.",
-      "description_configured": "[%key:component::climate::triggers::turned_off::description%]",
+      "description": "Triggers after one or more climate-control devices turn off.",
       "fields": {
         "behavior": {
           "description": "[%key:component::climate::common::trigger_behavior_description%]",
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         }
       },
-      "name": "When a climate is turned off"
+      "name": "Climate-control device turned off"
     },
     "turned_on": {
-      "description": "Triggers when a climate is turned on.",
-      "description_configured": "[%key:component::climate::triggers::turned_on::description%]",
+      "description": "Triggers after one or more climate-control devices turn on, regardless of the mode.",
       "fields": {
         "behavior": {
           "description": "[%key:component::climate::common::trigger_behavior_description%]",
           "name": "[%key:component::climate::common::trigger_behavior_name%]"
         }
       },
-      "name": "When a climate is turned on"
+      "name": "Climate-control device turned on"
     }
   }
 }

homeassistant/components/climate/trigger.py

@@ -11,6 +11,12 @@ from homeassistant.helpers.trigger import (
 from .const import ATTR_HVAC_ACTION, DOMAIN, HVACAction, HVACMode
 
 TRIGGERS: dict[str, type[Trigger]] = {
+    "started_cooling": make_entity_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.COOLING
+    ),
+    "started_drying": make_entity_state_attribute_trigger(
+        DOMAIN, ATTR_HVAC_ACTION, HVACAction.DRYING
+    ),
     "turned_off": make_entity_state_trigger(DOMAIN, HVACMode.OFF),
     "turned_on": make_conditional_entity_state_trigger(
         DOMAIN,

homeassistant/components/climate/triggers.yaml

@@ -14,6 +14,8 @@
             - last
             - any
 
+started_cooling: *trigger_common
+started_drying: *trigger_common
 started_heating: *trigger_common
 turned_off: *trigger_common
 turned_on: *trigger_common

homeassistant/components/cloud/__init__.py

@@ -4,12 +4,13 @@ from __future__ import annotations
 
 import asyncio
 from collections.abc import Awaitable, Callable
+from contextlib import suppress
 from datetime import datetime, timedelta
 from enum import Enum
 import logging
 from typing import Any, cast
 
-from hass_nabucasa import Cloud
+from hass_nabucasa import Cloud, NabuCasaBaseError
 import voluptuous as vol
 
 from homeassistant.components import alexa, google_assistant
@@ -78,13 +79,16 @@ from .subscription import async_subscription_info
 DEFAULT_MODE = MODE_PROD
 
 PLATFORMS = [
-    Platform.AI_TASK,
     Platform.BINARY_SENSOR,
-    Platform.CONVERSATION,
     Platform.STT,
     Platform.TTS,
 ]
 
+LLM_PLATFORMS = [
+    Platform.AI_TASK,
+    Platform.CONVERSATION,
+]
+
 SERVICE_REMOTE_CONNECT = "remote_connect"
 SERVICE_REMOTE_DISCONNECT = "remote_disconnect"
 
@@ -431,7 +435,14 @@ def _handle_prefs_updated(hass: HomeAssistant, cloud: Cloud[CloudClient]) -> Non
 
 async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Set up a config entry."""
-    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    platforms = PLATFORMS.copy()
+    if (cloud := hass.data[DATA_CLOUD]).is_logged_in:
+        with suppress(NabuCasaBaseError):
+            await cloud.llm.async_ensure_token()
+            platforms += LLM_PLATFORMS
+
+    await hass.config_entries.async_forward_entry_setups(entry, platforms)
+    entry.runtime_data = {"platforms": platforms}
     stt_tts_entities_added = hass.data[DATA_PLATFORMS_SETUP]["stt_tts_entities_added"]
     stt_tts_entities_added.set()
 
@@ -440,7 +451,9 @@ async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
 
 async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
     """Unload a config entry."""
-    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    return await hass.config_entries.async_unload_platforms(
+        entry, entry.runtime_data["platforms"]
+    )
 
 
 @callback

homeassistant/components/cloud/ai_task.py

@@ -19,7 +19,7 @@ from PIL import Image
 from homeassistant.components import ai_task, conversation
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.json import json_loads
 
@@ -94,15 +94,10 @@ async def async_setup_entry(
 ) -> None:
     """Set up Home Assistant Cloud AI Task entity."""
     cloud = hass.data[DATA_CLOUD]
-    try:
-        await cloud.llm.async_ensure_token()
-    except LLMError:
-        return
-
-    async_add_entities([CloudLLMTaskEntity(cloud, config_entry)])
+    async_add_entities([CloudAITaskEntity(cloud, config_entry)])
 
 
-class CloudLLMTaskEntity(ai_task.AITaskEntity, BaseCloudLLMEntity):
+class CloudAITaskEntity(BaseCloudLLMEntity, ai_task.AITaskEntity):
     """Home Assistant Cloud AI Task entity."""
 
     _attr_has_entity_name = True
@@ -179,7 +174,7 @@ class CloudLLMTaskEntity(ai_task.AITaskEntity, BaseCloudLLMEntity):
                     attachments=attachments,
                 )
         except LLMAuthenticationError as err:
-            raise ConfigEntryAuthFailed("Cloud LLM authentication failed") from err
+            raise HomeAssistantError("Cloud LLM authentication failed") from err
         except LLMRateLimitError as err:
             raise HomeAssistantError("Cloud LLM is rate limited") from err
         except LLMResponseError as err:

homeassistant/components/cloud/client.py

@@ -71,6 +71,7 @@ class CloudClient(Interface):
         self._google_config_init_lock = asyncio.Lock()
         self._relayer_region: str | None = None
         self._cloud_ice_servers_listener: Callable[[], None] | None = None
+        self._ice_servers: list[RTCIceServer] = []
 
     @property
     def base_path(self) -> Path:
@@ -117,6 +118,11 @@ class CloudClient(Interface):
         """Return the connected relayer region."""
         return self._relayer_region
 
+    @property
+    def ice_servers(self) -> list[RTCIceServer]:
+        """Return the current ICE servers."""
+        return self._ice_servers
+
     async def get_alexa_config(self) -> alexa_config.CloudAlexaConfig:
         """Return Alexa config."""
         if self._alexa_config is None:
@@ -203,11 +209,8 @@ class CloudClient(Interface):
                 ice_servers: list[RTCIceServer],
             ) -> Callable[[], None]:
                 """Register cloud ice server."""
-
-                def get_ice_servers() -> list[RTCIceServer]:
-                    return ice_servers
-
-                return async_register_ice_servers(self._hass, get_ice_servers)
+                self._ice_servers = ice_servers
+                return async_register_ice_servers(self._hass, lambda: self._ice_servers)
 
             async def async_register_cloud_ice_servers_listener(
                 prefs: CloudPreferences,
@@ -268,6 +271,7 @@ class CloudClient(Interface):
 
     async def logout_cleanups(self) -> None:
         """Cleanup some stuff after logout."""
+        self._ice_servers = []
         await self.prefs.async_set_username(None)
 
         if self._alexa_config:

homeassistant/components/cloud/conversation.py

@@ -4,8 +4,6 @@ from __future__ import annotations
 
 from typing import Literal
 
-from hass_nabucasa.llm import LLMError
-
 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import MATCH_ALL
@@ -24,17 +22,12 @@ async def async_setup_entry(
 ) -> None:
     """Set up the Home Assistant Cloud conversation entity."""
     cloud = hass.data[DATA_CLOUD]
-    try:
-        await cloud.llm.async_ensure_token()
-    except LLMError:
-        return
-
     async_add_entities([CloudConversationEntity(cloud, config_entry)])
 
 
 class CloudConversationEntity(
-    conversation.ConversationEntity,
     BaseCloudLLMEntity,
+    conversation.ConversationEntity,
 ):
     """Home Assistant Cloud conversation agent."""
 

homeassistant/components/cloud/entity.py

@@ -8,10 +8,9 @@ import logging
 import re
 from typing import Any, Literal, cast
 
-from hass_nabucasa import Cloud
+from hass_nabucasa import Cloud, NabuCasaBaseError
 from hass_nabucasa.llm import (
     LLMAuthenticationError,
-    LLMError,
     LLMRateLimitError,
     LLMResponseError,
     LLMServiceError,
@@ -37,7 +36,7 @@ from voluptuous_openapi import convert
 
 from homeassistant.components import conversation
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.exceptions import ConfigEntryAuthFailed, HomeAssistantError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers import llm
 from homeassistant.helpers.entity import Entity
 from homeassistant.util import slugify
@@ -562,7 +561,7 @@ class BaseCloudLLMEntity(Entity):
                         "schema": _format_structured_output(
                             structure, chat_log.llm_api
                         ),
-                        "strict": True,
+                        "strict": False,
                     },
                 }
 
@@ -601,14 +600,14 @@ class BaseCloudLLMEntity(Entity):
                 )
 
             except LLMAuthenticationError as err:
-                raise ConfigEntryAuthFailed("Cloud LLM authentication failed") from err
+                raise HomeAssistantError("Cloud LLM authentication failed") from err
             except LLMRateLimitError as err:
                 raise HomeAssistantError("Cloud LLM is rate limited") from err
             except LLMResponseError as err:
                 raise HomeAssistantError(str(err)) from err
             except LLMServiceError as err:
                 raise HomeAssistantError("Error talking to Cloud LLM") from err
-            except LLMError as err:
+            except NabuCasaBaseError as err:
                 raise HomeAssistantError(str(err)) from err
 
             if not chat_log.unresponded_tool_results:

homeassistant/components/cloud/http_api.py

@@ -99,6 +99,7 @@ def async_setup(hass: HomeAssistant) -> None:
     websocket_api.async_register_command(hass, websocket_hook_delete)
     websocket_api.async_register_command(hass, websocket_remote_connect)
     websocket_api.async_register_command(hass, websocket_remote_disconnect)
+    websocket_api.async_register_command(hass, websocket_webrtc_ice_servers)
 
     websocket_api.async_register_command(hass, google_assistant_get)
     websocket_api.async_register_command(hass, google_assistant_list)
@@ -1107,6 +1108,7 @@ async def alexa_sync(
 
 
 @websocket_api.websocket_command({"type": "cloud/tts/info"})
+@callback
 def tts_info(
     hass: HomeAssistant,
     connection: websocket_api.ActiveConnection,
@@ -1134,3 +1136,22 @@ def tts_info(
             )
 
     connection.send_result(msg["id"], {"languages": result})
+
+
+@websocket_api.websocket_command(
+    {
+        vol.Required("type"): "cloud/webrtc/ice_servers",
+    }
+)
+@_require_cloud_login
+@callback
+def websocket_webrtc_ice_servers(
+    hass: HomeAssistant,
+    connection: websocket_api.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Handle get WebRTC ICE servers websocket command."""
+    connection.send_result(
+        msg["id"],
+        [server.to_dict() for server in hass.data[DATA_CLOUD].client.ice_servers],
+    )

homeassistant/components/cloud/manifest.json

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

homeassistant/components/conversation/__init__.py

@@ -236,7 +236,9 @@ async def async_prepare_agent(
 
 
 async def async_handle_sentence_triggers(
-    hass: HomeAssistant, user_input: ConversationInput
+    hass: HomeAssistant,
+    user_input: ConversationInput,
+    chat_log: ChatLog,
 ) -> str | None:
     """Try to match input against sentence triggers and return response text.
 
@@ -245,12 +247,13 @@ async def async_handle_sentence_triggers(
     agent = get_agent_manager(hass).default_agent
     assert agent is not None
 
-    return await agent.async_handle_sentence_triggers(user_input)
+    return await agent.async_handle_sentence_triggers(user_input, chat_log)
 
 
 async def async_handle_intents(
     hass: HomeAssistant,
     user_input: ConversationInput,
+    chat_log: ChatLog,
     *,
     intent_filter: Callable[[RecognizeResult], bool] | None = None,
 ) -> intent.IntentResponse | None:
@@ -261,7 +264,9 @@ async def async_handle_intents(
     agent = get_agent_manager(hass).default_agent
     assert agent is not None
 
-    return await agent.async_handle_intents(user_input, intent_filter=intent_filter)
+    return await agent.async_handle_intents(
+        user_input, chat_log, intent_filter=intent_filter
+    )
 
 
 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:

homeassistant/components/conversation/default_agent.py

@@ -66,6 +66,7 @@ from homeassistant.helpers import (
     entity_registry as er,
     floor_registry as fr,
     intent,
+    llm,
     start as ha_start,
     template,
     translation,
@@ -76,7 +77,7 @@ from homeassistant.util import language as language_util
 from homeassistant.util.json import JsonObjectType, json_loads_object
 
 from .agent_manager import get_agent_manager
-from .chat_log import AssistantContent, ChatLog
+from .chat_log import AssistantContent, ChatLog, ToolResultContent
 from .const import (
     DOMAIN,
     METADATA_CUSTOM_FILE,
@@ -435,7 +436,7 @@ class DefaultAgent(ConversationEntity):
         if trigger_result := await self.async_recognize_sentence_trigger(user_input):
             # Process callbacks and get response
             response_text = await self._handle_trigger_result(
-                trigger_result, user_input
+                trigger_result, user_input, chat_log
             )
 
             # Convert to conversation result
@@ -447,8 +448,9 @@ class DefaultAgent(ConversationEntity):
         if response is None:
             # Match intents
             intent_result = await self.async_recognize_intent(user_input)
+
             response = await self._async_process_intent_result(
-                intent_result, user_input
+                intent_result, user_input, chat_log
             )
 
         speech: str = response.speech.get("plain", {}).get("speech", "")
@@ -467,6 +469,7 @@ class DefaultAgent(ConversationEntity):
         self,
         result: RecognizeResult | None,
         user_input: ConversationInput,
+        chat_log: ChatLog,
     ) -> intent.IntentResponse:
         """Process user input with intents."""
         language = user_input.language or self.hass.config.language
@@ -529,12 +532,21 @@ class DefaultAgent(ConversationEntity):
             ConversationTraceEventType.TOOL_CALL,
             {
                 "intent_name": result.intent.name,
-                "slots": {
-                    entity.name: entity.value or entity.text
-                    for entity in result.entities_list
-                },
+                "slots": {entity.name: entity.value for entity in result.entities_list},
             },
         )
+        tool_input = llm.ToolInput(
+            tool_name=result.intent.name,
+            tool_args={entity.name: entity.value for entity in result.entities_list},
+            external=True,
+        )
+        chat_log.async_add_assistant_content_without_tools(
+            AssistantContent(
+                agent_id=user_input.agent_id,
+                content=None,
+                tool_calls=[tool_input],
+            )
+        )
 
         try:
             intent_response = await intent.async_handle(
@@ -597,6 +609,16 @@ class DefaultAgent(ConversationEntity):
                 )
                 intent_response.async_set_speech(speech)
 
+        tool_result = llm.IntentResponseDict(intent_response)
+        chat_log.async_add_assistant_content_without_tools(
+            ToolResultContent(
+                agent_id=user_input.agent_id,
+                tool_call_id=tool_input.id,
+                tool_name=tool_input.tool_name,
+                tool_result=tool_result,
+            )
+        )
+
         return intent_response
 
     def _recognize(
@@ -1523,16 +1545,31 @@ class DefaultAgent(ConversationEntity):
         )
 
     async def _handle_trigger_result(
-        self, result: SentenceTriggerResult, user_input: ConversationInput
+        self,
+        result: SentenceTriggerResult,
+        user_input: ConversationInput,
+        chat_log: ChatLog,
     ) -> str:
         """Run sentence trigger callbacks and return response text."""
-
         # Gather callback responses in parallel
         trigger_callbacks = [
             self._triggers_details[trigger_id].callback(user_input, trigger_result)
             for trigger_id, trigger_result in result.matched_triggers.items()
         ]
 
+        tool_input = llm.ToolInput(
+            tool_name="trigger_sentence",
+            tool_args={},
+            external=True,
+        )
+        chat_log.async_add_assistant_content_without_tools(
+            AssistantContent(
+                agent_id=user_input.agent_id,
+                content=None,
+                tool_calls=[tool_input],
+            )
+        )
+
         # Use first non-empty result as response.
         #
         # There may be multiple copies of a trigger running when editing in
@@ -1561,23 +1598,38 @@ class DefaultAgent(ConversationEntity):
                 f"component.{DOMAIN}.conversation.agent.done", "Done"
             )
 
+        tool_result: dict[str, Any] = {"response": response_text}
+        chat_log.async_add_assistant_content_without_tools(
+            ToolResultContent(
+                agent_id=user_input.agent_id,
+                tool_call_id=tool_input.id,
+                tool_name=tool_input.tool_name,
+                tool_result=tool_result,
+            )
+        )
+
         return response_text
 
     async def async_handle_sentence_triggers(
-        self, user_input: ConversationInput
+        self,
+        user_input: ConversationInput,
+        chat_log: ChatLog,
     ) -> str | None:
         """Try to input sentence against sentence triggers and return response text.
 
         Returns None if no match occurred.
         """
         if trigger_result := await self.async_recognize_sentence_trigger(user_input):
-            return await self._handle_trigger_result(trigger_result, user_input)
+            return await self._handle_trigger_result(
+                trigger_result, user_input, chat_log
+            )
 
         return None
 
     async def async_handle_intents(
         self,
         user_input: ConversationInput,
+        chat_log: ChatLog,
         *,
         intent_filter: Callable[[RecognizeResult], bool] | None = None,
     ) -> intent.IntentResponse | None:
@@ -1593,7 +1645,7 @@ class DefaultAgent(ConversationEntity):
             # No error message on failed match
             return None
 
-        response = await self._async_process_intent_result(result, user_input)
+        response = await self._async_process_intent_result(result, user_input, chat_log)
         if (
             response.response_type == intent.IntentResponseType.ERROR
             and response.error_code

homeassistant/components/conversation/manifest.json

@@ -6,5 +6,5 @@
   "documentation": "https://www.home-assistant.io/integrations/conversation",
   "integration_type": "entity",
   "quality_scale": "internal",
-  "requirements": ["hassil==3.4.0", "home-assistant-intents==2025.11.24"]
+  "requirements": ["hassil==3.5.0", "home-assistant-intents==2025.12.2"]
 }

homeassistant/components/coolmaster/climate.py

@@ -8,6 +8,10 @@ from typing import Any
 from pycoolmasternet_async import SWING_MODES
 
 from homeassistant.components.climate import (
+    FAN_AUTO,
+    FAN_HIGH,
+    FAN_LOW,
+    FAN_MEDIUM,
     ClimateEntity,
     ClimateEntityFeature,
     HVACMode,
@@ -31,7 +35,16 @@ CM_TO_HA_STATE = {
 
 HA_STATE_TO_CM = {value: key for key, value in CM_TO_HA_STATE.items()}
 
-FAN_MODES = ["low", "med", "high", "auto"]
+CM_TO_HA_FAN = {
+    "low": FAN_LOW,
+    "med": FAN_MEDIUM,
+    "high": FAN_HIGH,
+    "auto": FAN_AUTO,
+}
+
+HA_FAN_TO_CM = {value: key for key, value in CM_TO_HA_FAN.items()}
+
+FAN_MODES = list(CM_TO_HA_FAN.values())
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -111,7 +124,7 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity):
     @property
     def fan_mode(self):
         """Return the fan setting."""
-        return self._unit.fan_speed
+        return CM_TO_HA_FAN[self._unit.fan_speed]
 
     @property
     def fan_modes(self):
@@ -138,7 +151,7 @@ class CoolmasterClimate(CoolmasterEntity, ClimateEntity):
     async def async_set_fan_mode(self, fan_mode: str) -> None:
         """Set new fan mode."""
         _LOGGER.debug("Setting fan mode of %s to %s", self.unique_id, fan_mode)
-        self._unit = await self._unit.set_fan_speed(fan_mode)
+        self._unit = await self._unit.set_fan_speed(HA_FAN_TO_CM[fan_mode])
         self.async_write_ha_state()
 
     async def async_set_swing_mode(self, swing_mode: str) -> None:

homeassistant/components/cover/icons.json

@@ -108,34 +108,5 @@
     "toggle_cover_tilt": {
       "service": "mdi:arrow-top-right-bottom-left"
     }
-  },
-  "triggers": {
-    "awning_opened": {
-      "trigger": "mdi:awning-outline"
-    },
-    "blind_opened": {
-      "trigger": "mdi:blinds-horizontal"
-    },
-    "curtain_opened": {
-      "trigger": "mdi:curtains"
-    },
-    "door_opened": {
-      "trigger": "mdi:door-open"
-    },
-    "garage_opened": {
-      "trigger": "mdi:garage-open"
-    },
-    "gate_opened": {
-      "trigger": "mdi:gate-open"
-    },
-    "shade_opened": {
-      "trigger": "mdi:roller-shade"
-    },
-    "shutter_opened": {
-      "trigger": "mdi:window-shutter-open"
-    },
-    "window_opened": {
-      "trigger": "mdi:window-open"
-    }
   }
 }

homeassistant/components/cover/strings.json

@@ -1,16 +1,4 @@
 {
-  "common": {
-    "trigger_behavior_description_awning": "The behavior of the targeted awnings to trigger on.",
-    "trigger_behavior_description_blind": "The behavior of the targeted blinds to trigger on.",
-    "trigger_behavior_description_curtain": "The behavior of the targeted curtains to trigger on.",
-    "trigger_behavior_description_door": "The behavior of the targeted doors to trigger on.",
-    "trigger_behavior_description_garage": "The behavior of the targeted garage doors to trigger on.",
-    "trigger_behavior_description_gate": "The behavior of the targeted gates to trigger on.",
-    "trigger_behavior_description_shade": "The behavior of the targeted shades to trigger on.",
-    "trigger_behavior_description_shutter": "The behavior of the targeted shutters to trigger on.",
-    "trigger_behavior_description_window": "The behavior of the targeted windows to trigger on.",
-    "trigger_behavior_name": "Behavior"
-  },
   "device_automation": {
     "action_type": {
       "close": "Close {entity_name}",
@@ -94,15 +82,6 @@
       "name": "Window"
     }
   },
-  "selector": {
-    "trigger_behavior": {
-      "options": {
-        "any": "Any",
-        "first": "First",
-        "last": "Last"
-      }
-    }
-  },
   "services": {
     "close_cover": {
       "description": "Closes a cover.",
@@ -157,142 +136,5 @@
       "name": "Toggle tilt"
     }
   },
-  "title": "Cover",
-  "triggers": {
-    "awning_opened": {
-      "description": "Triggers when an awning opens.",
-      "description_configured": "[%key:component::cover::triggers::awning_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_awning%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the awnings to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When an awning opens"
-    },
-    "blind_opened": {
-      "description": "Triggers when a blind opens.",
-      "description_configured": "[%key:component::cover::triggers::blind_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_blind%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the blinds to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a blind opens"
-    },
-    "curtain_opened": {
-      "description": "Triggers when a curtain opens.",
-      "description_configured": "[%key:component::cover::triggers::curtain_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_curtain%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the curtains to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a curtain opens"
-    },
-    "door_opened": {
-      "description": "Triggers when a door opens.",
-      "description_configured": "[%key:component::cover::triggers::door_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_door%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the doors to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a door opens"
-    },
-    "garage_opened": {
-      "description": "Triggers when a garage door opens.",
-      "description_configured": "[%key:component::cover::triggers::garage_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_garage%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the garage doors to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a garage door opens"
-    },
-    "gate_opened": {
-      "description": "Triggers when a gate opens.",
-      "description_configured": "[%key:component::cover::triggers::gate_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_gate%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the gates to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a gate opens"
-    },
-    "shade_opened": {
-      "description": "Triggers when a shade opens.",
-      "description_configured": "[%key:component::cover::triggers::shade_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_shade%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the shades to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a shade opens"
-    },
-    "shutter_opened": {
-      "description": "Triggers when a shutter opens.",
-      "description_configured": "[%key:component::cover::triggers::shutter_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_shutter%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the shutters to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a shutter opens"
-    },
-    "window_opened": {
-      "description": "Triggers when a window opens.",
-      "description_configured": "[%key:component::cover::triggers::window_opened::description%]",
-      "fields": {
-        "behavior": {
-          "description": "[%key:component::cover::common::trigger_behavior_description_window%]",
-          "name": "[%key:component::cover::common::trigger_behavior_name%]"
-        },
-        "fully_opened": {
-          "description": "Require the windows to be fully opened before triggering.",
-          "name": "Fully opened"
-        }
-      },
-      "name": "When a window opens"
-    }
-  }
+  "title": "Cover"
 }

homeassistant/components/cover/trigger.py

@@ -1,116 +0,0 @@
-"""Provides triggers for covers."""
-
-from typing import Final
-
-import voluptuous as vol
-
-from homeassistant.const import CONF_OPTIONS
-from homeassistant.core import HomeAssistant, State
-from homeassistant.exceptions import HomeAssistantError
-from homeassistant.helpers.entity import get_device_class
-from homeassistant.helpers.trigger import (
-    ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST,
-    EntityTriggerBase,
-    Trigger,
-    TriggerConfig,
-)
-from homeassistant.helpers.typing import UNDEFINED, UndefinedType
-
-from . import ATTR_CURRENT_POSITION, CoverDeviceClass, CoverState
-from .const import DOMAIN
-
-ATTR_FULLY_OPENED: Final = "fully_opened"
-
-COVER_OPENED_TRIGGER_SCHEMA = ENTITY_STATE_TRIGGER_SCHEMA_FIRST_LAST.extend(
-    {
-        vol.Required(CONF_OPTIONS): {
-            vol.Required(ATTR_FULLY_OPENED, default=False): bool,
-        },
-    }
-)
-
-
-def get_device_class_or_undefined(
-    hass: HomeAssistant, entity_id: str
-) -> str | None | UndefinedType:
-    """Get the device class of an entity or UNDEFINED if not found."""
-    try:
-        return get_device_class(hass, entity_id)
-    except HomeAssistantError:
-        return UNDEFINED
-
-
-class CoverOpenedClosedTrigger(EntityTriggerBase):
-    """Class for cover opened and closed triggers."""
-
-    _attribute: str = ATTR_CURRENT_POSITION
-    _attribute_value: int | None = None
-    _device_class: CoverDeviceClass | None
-    _domain: str = DOMAIN
-    _to_states: set[str]
-
-    def is_to_state(self, state: State) -> bool:
-        """Check if the state matches the target state."""
-        if state.state not in self._to_states:
-            return False
-        if (
-            self._attribute_value is not None
-            and (value := state.attributes.get(self._attribute)) is not None
-            and value != self._attribute_value
-        ):
-            return False
-        return True
-
-    def entity_filter(self, entities: set[str]) -> set[str]:
-        """Filter entities of this domain."""
-        entities = super().entity_filter(entities)
-        return {
-            entity_id
-            for entity_id in entities
-            if get_device_class_or_undefined(self._hass, entity_id)
-            == self._device_class
-        }
-
-
-class CoverOpenedTrigger(CoverOpenedClosedTrigger):
-    """Class for cover opened triggers."""
-
-    _schema = COVER_OPENED_TRIGGER_SCHEMA
-    _to_states = {CoverState.OPEN, CoverState.OPENING}
-
-    def __init__(self, hass: HomeAssistant, config: TriggerConfig) -> None:
-        """Initialize the state trigger."""
-        super().__init__(hass, config)
-        if self._options.get(ATTR_FULLY_OPENED):
-            self._attribute_value = 100
-
-
-def make_cover_opened_trigger(
-    device_class: CoverDeviceClass | None,
-) -> type[CoverOpenedTrigger]:
-    """Create an entity state attribute trigger class."""
-
-    class CustomTrigger(CoverOpenedTrigger):
-        """Trigger for entity state changes."""
-
-        _device_class = device_class
-
-    return CustomTrigger
-
-
-TRIGGERS: dict[str, type[Trigger]] = {
-    "awning_opened": make_cover_opened_trigger(CoverDeviceClass.AWNING),
-    "blind_opened": make_cover_opened_trigger(CoverDeviceClass.BLIND),
-    "curtain_opened": make_cover_opened_trigger(CoverDeviceClass.CURTAIN),
-    "door_opened": make_cover_opened_trigger(CoverDeviceClass.DOOR),
-    "garage_opened": make_cover_opened_trigger(CoverDeviceClass.GARAGE),
-    "gate_opened": make_cover_opened_trigger(CoverDeviceClass.GATE),
-    "shade_opened": make_cover_opened_trigger(CoverDeviceClass.SHADE),
-    "shutter_opened": make_cover_opened_trigger(CoverDeviceClass.SHUTTER),
-    "window_opened": make_cover_opened_trigger(CoverDeviceClass.WINDOW),
-}
-
-
-async def async_get_triggers(hass: HomeAssistant) -> dict[str, type[Trigger]]:
-    """Return the triggers for covers."""
-    return TRIGGERS

homeassistant/components/cover/triggers.yaml

@@ -1,79 +0,0 @@
-.trigger_common_fields: &trigger_common_fields
-  behavior:
-    required: true
-    default: any
-    selector:
-      select:
-        translation_key: trigger_behavior
-        options:
-          - first
-          - last
-          - any
-  fully_opened:
-    required: true
-    default: false
-    selector:
-      boolean:
-
-awning_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: awning
-
-blind_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: blind
-
-curtain_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: curtain
-
-door_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: door
-
-garage_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: garage
-
-gate_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: gate
-
-shade_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: shade
-
-shutter_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: shutter
-
-window_opened:
-  fields: *trigger_common_fields
-  target:
-    entity:
-      domain: cover
-      device_class: window

homeassistant/components/dlna_dmr/manifest.json

@@ -6,6 +6,7 @@
   "config_flow": true,
   "dependencies": ["ssdp"],
   "documentation": "https://www.home-assistant.io/integrations/dlna_dmr",
+  "integration_type": "device",
   "iot_class": "local_push",
   "loggers": ["async_upnp_client"],
   "requirements": ["async-upnp-client==0.46.0", "getmac==0.9.5"],

homeassistant/components/dlna_dms/manifest.json

@@ -6,6 +6,7 @@
   "config_flow": true,
   "dependencies": ["ssdp"],
   "documentation": "https://www.home-assistant.io/integrations/dlna_dms",
+  "integration_type": "service",
   "iot_class": "local_polling",
   "requirements": ["async-upnp-client==0.46.0"],
   "ssdp": [

homeassistant/components/droplet/config_flow.py

@@ -15,6 +15,11 @@ from homeassistant.helpers.service_info.zeroconf import ZeroconfServiceInfo
 from .const import DOMAIN
 
 
+def normalize_pairing_code(code: str) -> str:
+    """Normalize pairing code by removing spaces and capitalizing."""
+    return code.replace(" ", "").upper()
+
+
 class DropletConfigFlow(ConfigFlow, domain=DOMAIN):
     """Handle Droplet config flow."""
 
@@ -52,14 +57,13 @@ class DropletConfigFlow(ConfigFlow, domain=DOMAIN):
         if user_input is not None:
             # Test if we can connect before returning
             session = async_get_clientsession(self.hass)
-            if await self._droplet_discovery.try_connect(
-                session, user_input[CONF_CODE]
-            ):
+            code = normalize_pairing_code(user_input[CONF_CODE])
+            if await self._droplet_discovery.try_connect(session, code):
                 device_data = {
                     CONF_IP_ADDRESS: self._droplet_discovery.host,
                     CONF_PORT: self._droplet_discovery.port,
                     CONF_DEVICE_ID: device_id,
-                    CONF_CODE: user_input[CONF_CODE],
+                    CONF_CODE: code,
                 }
 
                 return self.async_create_entry(
@@ -90,14 +94,15 @@ class DropletConfigFlow(ConfigFlow, domain=DOMAIN):
                 user_input[CONF_IP_ADDRESS], DropletConnection.DEFAULT_PORT, ""
             )
             session = async_get_clientsession(self.hass)
-            if await self._droplet_discovery.try_connect(
-                session, user_input[CONF_CODE]
-            ) and (device_id := await self._droplet_discovery.get_device_id()):
+            code = normalize_pairing_code(user_input[CONF_CODE])
+            if await self._droplet_discovery.try_connect(session, code) and (
+                device_id := await self._droplet_discovery.get_device_id()
+            ):
                 device_data = {
                     CONF_IP_ADDRESS: self._droplet_discovery.host,
                     CONF_PORT: self._droplet_discovery.port,
                     CONF_DEVICE_ID: device_id,
-                    CONF_CODE: user_input[CONF_CODE],
+                    CONF_CODE: code,
                 }
                 await self.async_set_unique_id(device_id, raise_on_progress=False)
                 self._abort_if_unique_id_configured(

homeassistant/components/ecovacs/manifest.json

@@ -7,5 +7,5 @@
   "integration_type": "hub",
   "iot_class": "cloud_push",
   "loggers": ["sleekxmppfs", "sucks", "deebot_client"],
-  "requirements": ["py-sucks==0.9.11", "deebot-client==16.3.0"]
+  "requirements": ["py-sucks==0.9.11", "deebot-client==17.0.0"]
 }

homeassistant/components/ecowitt/manifest.json

@@ -5,6 +5,7 @@
   "config_flow": true,
   "dependencies": ["webhook"],
   "documentation": "https://www.home-assistant.io/integrations/ecowitt",
+  "integration_type": "device",
   "iot_class": "local_push",
   "requirements": ["aioecowitt==2025.9.2"]
 }

homeassistant/components/ecowitt/sensor.py

@@ -285,16 +285,14 @@ async def async_setup_entry(
             name=sensor.name,
         )
 
-        # Hourly rain doesn't reset to fixed hours, it must be measurement state classes
+        # Only total rain needs state class for long-term statistics
         if sensor.key in (
-            "hrain_piezomm",
-            "hrain_piezo",
-            "hourlyrainmm",
-            "hourlyrainin",
+            "totalrainin",
+            "totalrainmm",
         ):
             description = dataclasses.replace(
                 description,
-                state_class=SensorStateClass.MEASUREMENT,
+                state_class=SensorStateClass.TOTAL_INCREASING,
             )
 
         async_add_entities([EcowittSensorEntity(sensor, description)])

homeassistant/components/elevenlabs/const.py

@@ -17,7 +17,7 @@ DEFAULT_TTS_MODEL = "eleven_multilingual_v2"
 DEFAULT_STABILITY = 0.5
 DEFAULT_SIMILARITY = 0.75
 DEFAULT_STT_AUTO_LANGUAGE = False
-DEFAULT_STT_MODEL = "scribe_v1"
+DEFAULT_STT_MODEL = "scribe_v2"
 DEFAULT_STYLE = 0
 DEFAULT_USE_SPEAKER_BOOST = True
 
@@ -129,4 +129,5 @@ STT_LANGUAGES = [
 STT_MODELS = {
     "scribe_v1": "Scribe v1",
     "scribe_v1_experimental": "Scribe v1 Experimental",
+    "scribe_v2": "Scribe v2 Realtime",
 }

homeassistant/components/energyid/__init__.py

@@ -0,0 +1,401 @@
+"""The EnergyID integration."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+import datetime as dt
+from datetime import timedelta
+import functools
+import logging
+
+from aiohttp import ClientError, ClientResponseError
+from energyid_webhooks.client_v2 import WebhookClient
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import STATE_UNAVAILABLE, STATE_UNKNOWN
+from homeassistant.core import (
+    CALLBACK_TYPE,
+    Event,
+    EventStateChangedData,
+    HomeAssistant,
+    callback,
+)
+from homeassistant.exceptions import ConfigEntryAuthFailed, ConfigEntryNotReady
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.event import (
+    async_track_entity_registry_updated_event,
+    async_track_state_change_event,
+    async_track_time_interval,
+)
+
+from .const import (
+    CONF_DEVICE_ID,
+    CONF_DEVICE_NAME,
+    CONF_ENERGYID_KEY,
+    CONF_HA_ENTITY_UUID,
+    CONF_PROVISIONING_KEY,
+    CONF_PROVISIONING_SECRET,
+    DOMAIN,
+)
+
+_LOGGER = logging.getLogger(__name__)
+
+type EnergyIDConfigEntry = ConfigEntry[EnergyIDRuntimeData]
+
+DEFAULT_UPLOAD_INTERVAL_SECONDS = 60
+
+
+@dataclass
+class EnergyIDRuntimeData:
+    """Runtime data for the EnergyID integration."""
+
+    client: WebhookClient
+    mappings: dict[str, str]
+    state_listener: CALLBACK_TYPE | None = None
+    registry_tracking_listener: CALLBACK_TYPE | None = None
+    unavailable_logged: bool = False
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> bool:
+    """Set up EnergyID from a config entry."""
+    session = async_get_clientsession(hass)
+    client = WebhookClient(
+        provisioning_key=entry.data[CONF_PROVISIONING_KEY],
+        provisioning_secret=entry.data[CONF_PROVISIONING_SECRET],
+        device_id=entry.data[CONF_DEVICE_ID],
+        device_name=entry.data[CONF_DEVICE_NAME],
+        session=session,
+    )
+
+    entry.runtime_data = EnergyIDRuntimeData(
+        client=client,
+        mappings={},
+    )
+
+    is_claimed = None
+    try:
+        is_claimed = await client.authenticate()
+    except TimeoutError as err:
+        raise ConfigEntryNotReady(
+            f"Timeout authenticating with EnergyID: {err}"
+        ) from err
+    except ClientResponseError as err:
+        # 401/403 = invalid credentials, trigger reauth
+        if err.status in (401, 403):
+            raise ConfigEntryAuthFailed(f"Invalid credentials: {err}") from err
+        # Other HTTP errors are likely temporary
+        raise ConfigEntryNotReady(
+            f"HTTP error authenticating with EnergyID: {err}"
+        ) from err
+    except ClientError as err:
+        # Network/connection errors are temporary
+        raise ConfigEntryNotReady(
+            f"Connection error authenticating with EnergyID: {err}"
+        ) from err
+    except Exception as err:
+        # Unknown errors - log and retry (safer than forcing reauth)
+        _LOGGER.exception("Unexpected error during EnergyID authentication")
+        raise ConfigEntryNotReady(
+            f"Unexpected error authenticating with EnergyID: {err}"
+        ) from err
+
+    if not is_claimed:
+        # Device exists but not claimed = user needs to claim it = auth issue
+        raise ConfigEntryAuthFailed("Device is not claimed. Please re-authenticate.")
+
+    _LOGGER.debug("EnergyID device '%s' authenticated successfully", client.device_name)
+
+    async def _async_synchronize_sensors(now: dt.datetime | None = None) -> None:
+        """Callback for periodically synchronizing sensor data."""
+        try:
+            await client.synchronize_sensors()
+            if entry.runtime_data.unavailable_logged:
+                _LOGGER.debug("Connection to EnergyID re-established")
+                entry.runtime_data.unavailable_logged = False
+        except (OSError, RuntimeError) as err:
+            if not entry.runtime_data.unavailable_logged:
+                _LOGGER.debug("EnergyID is unavailable: %s", err)
+                entry.runtime_data.unavailable_logged = True
+
+    upload_interval = DEFAULT_UPLOAD_INTERVAL_SECONDS
+    if client.webhook_policy:
+        upload_interval = client.webhook_policy.get(
+            "uploadInterval", DEFAULT_UPLOAD_INTERVAL_SECONDS
+        )
+
+    # Schedule the callback and automatically unsubscribe when the entry is unloaded.
+    entry.async_on_unload(
+        async_track_time_interval(
+            hass, _async_synchronize_sensors, timedelta(seconds=upload_interval)
+        )
+    )
+    entry.async_on_unload(entry.add_update_listener(config_entry_update_listener))
+
+    update_listeners(hass, entry)
+
+    _LOGGER.debug(
+        "Starting EnergyID background sync for '%s'",
+        client.device_name,
+    )
+
+    return True
+
+
+async def config_entry_update_listener(
+    hass: HomeAssistant, entry: EnergyIDConfigEntry
+) -> None:
+    """Handle config entry updates, including subentry changes."""
+    _LOGGER.debug("Config entry updated for %s, reloading listeners", entry.entry_id)
+    update_listeners(hass, entry)
+
+
+@callback
+def update_listeners(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> None:
+    """Set up or update state listeners and queue initial states."""
+    runtime_data = entry.runtime_data
+    client = runtime_data.client
+
+    # Clean up old state listener
+    if runtime_data.state_listener:
+        runtime_data.state_listener()
+        runtime_data.state_listener = None
+
+    mappings: dict[str, str] = {}
+    entities_to_track: list[str] = []
+    old_mappings = set(runtime_data.mappings.keys())
+    new_mappings = set()
+    ent_reg = er.async_get(hass)
+
+    subentries = list(entry.subentries.values())
+    _LOGGER.debug(
+        "Found %d subentries in entry.subentries: %s",
+        len(subentries),
+        [s.data for s in subentries],
+    )
+
+    # Build current entity mappings
+    tracked_entity_ids = []
+    for subentry in subentries:
+        entity_uuid = subentry.data.get(CONF_HA_ENTITY_UUID)
+        energyid_key = subentry.data.get(CONF_ENERGYID_KEY)
+
+        if not (entity_uuid and energyid_key):
+            continue
+
+        entity_entry = ent_reg.async_get(entity_uuid)
+        if not entity_entry:
+            _LOGGER.warning(
+                "Entity with UUID %s does not exist, skipping mapping to %s",
+                entity_uuid,
+                energyid_key,
+            )
+            continue
+
+        ha_entity_id = entity_entry.entity_id
+        tracked_entity_ids.append(ha_entity_id)
+
+        if not hass.states.get(ha_entity_id):
+            # Entity exists in registry but is not present in the state machine
+            _LOGGER.debug(
+                "Entity %s does not exist in state machine yet, will track when available (mapping to %s)",
+                ha_entity_id,
+                energyid_key,
+            )
+            # Still add to entities_to_track so we can handle it when state appears
+            entities_to_track.append(ha_entity_id)
+            continue
+
+        mappings[ha_entity_id] = energyid_key
+        entities_to_track.append(ha_entity_id)
+        new_mappings.add(ha_entity_id)
+        client.get_or_create_sensor(energyid_key)
+
+        if ha_entity_id not in old_mappings:
+            _LOGGER.debug(
+                "New mapping detected for %s, queuing initial state", ha_entity_id
+            )
+            if (
+                current_state := hass.states.get(ha_entity_id)
+            ) and current_state.state not in (
+                STATE_UNKNOWN,
+                STATE_UNAVAILABLE,
+            ):
+                try:
+                    value = float(current_state.state)
+                    timestamp = current_state.last_updated or dt.datetime.now(dt.UTC)
+                    client.get_or_create_sensor(energyid_key).update(value, timestamp)
+                except (ValueError, TypeError):
+                    _LOGGER.debug(
+                        "Could not convert initial state of %s to float: %s",
+                        ha_entity_id,
+                        current_state.state,
+                    )
+
+    # Clean up old entity registry listener
+    if runtime_data.registry_tracking_listener:
+        runtime_data.registry_tracking_listener()
+        runtime_data.registry_tracking_listener = None
+
+    # Set up listeners for entity registry changes
+    if tracked_entity_ids:
+        _LOGGER.debug("Setting up entity registry tracking for: %s", tracked_entity_ids)
+
+        def _handle_entity_registry_change(
+            event: Event[er.EventEntityRegistryUpdatedData],
+        ) -> None:
+            """Handle entity registry changes for our tracked entities."""
+            _LOGGER.debug("Registry event for tracked entity: %s", event.data)
+
+            if event.data["action"] == "update":
+                # Type is now narrowed to _EventEntityRegistryUpdatedData_Update
+                if "entity_id" in event.data["changes"]:
+                    old_entity_id = event.data["changes"]["entity_id"]
+                    new_entity_id = event.data["entity_id"]
+
+                    _LOGGER.debug(
+                        "Tracked entity ID changed: %s -> %s",
+                        old_entity_id,
+                        new_entity_id,
+                    )
+                    # Entity ID changed, need to reload listeners to track new ID
+                    update_listeners(hass, entry)
+
+            elif event.data["action"] == "remove":
+                _LOGGER.debug("Tracked entity removed: %s", event.data["entity_id"])
+                # reminder: Create repair issue to notify user about removed entity
+                update_listeners(hass, entry)
+
+        # Track the specific entity IDs we care about
+        unsub_entity_registry = async_track_entity_registry_updated_event(
+            hass, tracked_entity_ids, _handle_entity_registry_change
+        )
+        runtime_data.registry_tracking_listener = unsub_entity_registry
+
+    if removed_mappings := old_mappings - new_mappings:
+        _LOGGER.debug("Removed mappings: %s", ", ".join(removed_mappings))
+
+    runtime_data.mappings = mappings
+
+    if not entities_to_track:
+        _LOGGER.debug(
+            "No valid sensor mappings configured for '%s'", client.device_name
+        )
+        return
+
+    unsub_state_change = async_track_state_change_event(
+        hass,
+        entities_to_track,
+        functools.partial(_async_handle_state_change, hass, entry.entry_id),
+    )
+    runtime_data.state_listener = unsub_state_change
+
+    _LOGGER.debug(
+        "Now tracking state changes for %d entities for '%s': %s",
+        len(entities_to_track),
+        client.device_name,
+        entities_to_track,
+    )
+
+
+@callback
+def _async_handle_state_change(
+    hass: HomeAssistant, entry_id: str, event: Event[EventStateChangedData]
+) -> None:
+    """Handle state changes for tracked entities."""
+    entity_id = event.data["entity_id"]
+    new_state = event.data["new_state"]
+
+    _LOGGER.debug(
+        "State change detected for entity: %s, new value: %s",
+        entity_id,
+        new_state.state if new_state else "None",
+    )
+
+    if not new_state or new_state.state in (STATE_UNKNOWN, STATE_UNAVAILABLE):
+        return
+
+    entry = hass.config_entries.async_get_entry(entry_id)
+    if not entry or not hasattr(entry, "runtime_data"):
+        # Entry is being unloaded or not yet fully initialized
+        return
+
+    runtime_data = entry.runtime_data
+    client = runtime_data.client
+
+    # Check if entity is already mapped
+    if energyid_key := runtime_data.mappings.get(entity_id):
+        # Entity already mapped, just update value
+        _LOGGER.debug(
+            "Updating EnergyID sensor %s with value %s", energyid_key, new_state.state
+        )
+    else:
+        # Entity not mapped yet - check if it should be (handles late-appearing entities)
+        ent_reg = er.async_get(hass)
+        for subentry in entry.subentries.values():
+            entity_uuid = subentry.data.get(CONF_HA_ENTITY_UUID)
+            energyid_key_candidate = subentry.data.get(CONF_ENERGYID_KEY)
+
+            if not (entity_uuid and energyid_key_candidate):
+                continue
+
+            entity_entry = ent_reg.async_get(entity_uuid)
+            if entity_entry and entity_entry.entity_id == entity_id:
+                # Found it! Add to mappings and send initial value
+                energyid_key = energyid_key_candidate
+                runtime_data.mappings[entity_id] = energyid_key
+                client.get_or_create_sensor(energyid_key)
+                _LOGGER.debug(
+                    "Entity %s now available in state machine, adding to mappings (key: %s)",
+                    entity_id,
+                    energyid_key,
+                )
+                break
+        else:
+            # Not a tracked entity, ignore
+            return
+
+    try:
+        value = float(new_state.state)
+    except (ValueError, TypeError):
+        return
+
+    client.get_or_create_sensor(energyid_key).update(value, new_state.last_updated)
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: EnergyIDConfigEntry) -> bool:
+    """Unload a config entry."""
+    _LOGGER.debug("Unloading EnergyID entry for %s", entry.title)
+
+    try:
+        # Unload subentries if present (guarded for test and reload scenarios)
+        if hasattr(hass.config_entries, "async_entries") and hasattr(entry, "entry_id"):
+            subentries = [
+                e.entry_id
+                for e in hass.config_entries.async_entries(DOMAIN)
+                if getattr(e, "parent_entry", None) == entry.entry_id
+            ]
+            for subentry_id in subentries:
+                await hass.config_entries.async_unload(subentry_id)
+
+        # Only clean up listeners and client if runtime_data is present
+        if hasattr(entry, "runtime_data"):
+            runtime_data = entry.runtime_data
+
+            # Remove state listener
+            if runtime_data.state_listener:
+                runtime_data.state_listener()
+
+            # Remove registry tracking listener
+            if runtime_data.registry_tracking_listener:
+                runtime_data.registry_tracking_listener()
+
+            try:
+                await runtime_data.client.close()
+            except Exception:
+                _LOGGER.exception("Error closing EnergyID client for %s", entry.title)
+            del entry.runtime_data
+    except Exception:
+        _LOGGER.exception("Error during async_unload_entry for %s", entry.title)
+        return False
+    return True

homeassistant/components/energyid/config_flow.py

@@ -0,0 +1,293 @@
+"""Config flow for EnergyID integration."""
+
+import asyncio
+from collections.abc import Mapping
+import logging
+from typing import Any
+
+from aiohttp import ClientError, ClientResponseError
+from energyid_webhooks.client_v2 import WebhookClient
+import voluptuous as vol
+
+from homeassistant.config_entries import (
+    ConfigEntry,
+    ConfigFlow,
+    ConfigFlowResult,
+    ConfigSubentryFlow,
+)
+from homeassistant.core import callback
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+import homeassistant.helpers.config_validation as cv
+from homeassistant.helpers.instance_id import async_get as async_get_instance_id
+
+from .const import (
+    CONF_DEVICE_ID,
+    CONF_DEVICE_NAME,
+    CONF_PROVISIONING_KEY,
+    CONF_PROVISIONING_SECRET,
+    DOMAIN,
+    ENERGYID_DEVICE_ID_FOR_WEBHOOK_PREFIX,
+    MAX_POLLING_ATTEMPTS,
+    NAME,
+    POLLING_INTERVAL,
+)
+from .energyid_sensor_mapping_flow import EnergyIDSensorMappingFlowHandler
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class EnergyIDConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle the configuration flow for the EnergyID integration."""
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._flow_data: dict[str, Any] = {}
+        self._polling_task: asyncio.Task | None = None
+
+    async def _perform_auth_and_get_details(self) -> str | None:
+        """Authenticate with EnergyID and retrieve device details."""
+        _LOGGER.debug("Starting authentication with EnergyID")
+        client = WebhookClient(
+            provisioning_key=self._flow_data[CONF_PROVISIONING_KEY],
+            provisioning_secret=self._flow_data[CONF_PROVISIONING_SECRET],
+            device_id=self._flow_data[CONF_DEVICE_ID],
+            device_name=self._flow_data[CONF_DEVICE_NAME],
+            session=async_get_clientsession(self.hass),
+        )
+        try:
+            is_claimed = await client.authenticate()
+        except ClientResponseError as err:
+            if err.status == 401:
+                _LOGGER.debug("Invalid provisioning key or secret")
+                return "invalid_auth"
+            _LOGGER.debug(
+                "Client response error during EnergyID authentication: %s", err
+            )
+            return "cannot_connect"
+        except ClientError as err:
+            _LOGGER.debug(
+                "Failed to connect to EnergyID during authentication: %s", err
+            )
+            return "cannot_connect"
+        except Exception:
+            _LOGGER.exception("Unexpected error during EnergyID authentication")
+            return "unknown_auth_error"
+        else:
+            _LOGGER.debug("Authentication successful, claimed: %s", is_claimed)
+
+        if is_claimed:
+            self._flow_data["record_number"] = client.recordNumber
+            self._flow_data["record_name"] = client.recordName
+            _LOGGER.debug(
+                "Device claimed with record number: %s, record name: %s",
+                client.recordNumber,
+                client.recordName,
+            )
+            return None
+
+        self._flow_data["claim_info"] = client.get_claim_info()
+        self._flow_data["claim_info"]["integration_name"] = NAME
+        _LOGGER.debug(
+            "Device needs claim, claim info: %s", self._flow_data["claim_info"]
+        )
+        return "needs_claim"
+
+    async def _async_poll_for_claim(self) -> None:
+        """Poll EnergyID to check if device has been claimed."""
+        for _attempt in range(1, MAX_POLLING_ATTEMPTS + 1):
+            await asyncio.sleep(POLLING_INTERVAL)
+
+            auth_status = await self._perform_auth_and_get_details()
+
+            if auth_status is None:
+                # Device claimed - advance flow to async_step_create_entry
+                _LOGGER.debug("Device claimed, advancing to create entry")
+                self.hass.async_create_task(
+                    self.hass.config_entries.flow.async_configure(self.flow_id)
+                )
+                return
+
+            if auth_status != "needs_claim":
+                # Stop polling on non-transient errors
+                # No user notification needed here as the error will be handled
+                # in the next flow step when the user continues the flow
+                _LOGGER.debug("Polling stopped due to error: %s", auth_status)
+                return
+
+        _LOGGER.debug("Polling timeout after %s attempts", MAX_POLLING_ATTEMPTS)
+        # No user notification here because:
+        # 1. User may still be completing the claim process in EnergyID portal
+        # 2. Immediate notification could interrupt their workflow or cause confusion
+        # 3. When user clicks "Submit" to continue, the flow validates claim status
+        #    and will show appropriate error/success messages based on current state
+        # 4. Timeout allows graceful fallback: user can retry claim or see proper error
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step of the configuration flow."""
+        _LOGGER.debug("Starting user step with input: %s", user_input)
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            instance_id = await async_get_instance_id(self.hass)
+            # Note: This device_id is for EnergyID's webhook system, not related to HA's device registry
+            device_suffix = f"{int(asyncio.get_event_loop().time() * 1000)}"
+            device_id = (
+                f"{ENERGYID_DEVICE_ID_FOR_WEBHOOK_PREFIX}{instance_id}_{device_suffix}"
+            )
+            self._flow_data = {
+                **user_input,
+                CONF_DEVICE_ID: device_id,
+                CONF_DEVICE_NAME: self.hass.config.location_name,
+            }
+            _LOGGER.debug("Flow data after user input: %s", self._flow_data)
+
+            auth_status = await self._perform_auth_and_get_details()
+
+            if auth_status is None:
+                await self.async_set_unique_id(device_id)
+                self._abort_if_unique_id_configured()
+                _LOGGER.debug(
+                    "Creating entry with title: %s", self._flow_data["record_name"]
+                )
+                return self.async_create_entry(
+                    title=self._flow_data["record_name"],
+                    data=self._flow_data,
+                    description="add_sensor_mapping_hint",
+                    description_placeholders={"integration_name": NAME},
+                )
+
+            if auth_status == "needs_claim":
+                _LOGGER.debug("Redirecting to auth and claim step")
+                return await self.async_step_auth_and_claim()
+
+            errors["base"] = auth_status
+            _LOGGER.debug("Errors encountered during user step: %s", errors)
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PROVISIONING_KEY): str,
+                    vol.Required(CONF_PROVISIONING_SECRET): cv.string,
+                }
+            ),
+            errors=errors,
+            description_placeholders={
+                "docs_url": "https://app.energyid.eu/integrations/home-assistant",
+                "integration_name": NAME,
+            },
+        )
+
+    async def async_step_auth_and_claim(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the step for device claiming using external step with polling."""
+        _LOGGER.debug("Starting auth and claim step with input: %s", user_input)
+
+        claim_info = self._flow_data.get("claim_info", {})
+
+        # Start polling when we first enter this step
+        if self._polling_task is None:
+            self._polling_task = self.hass.async_create_task(
+                self._async_poll_for_claim()
+            )
+
+            # Show external step to open the EnergyID website
+            return self.async_external_step(
+                step_id="auth_and_claim",
+                url=claim_info.get("claim_url", ""),
+                description_placeholders=claim_info,
+            )
+
+        # Check if device has been claimed
+        auth_status = await self._perform_auth_and_get_details()
+
+        if auth_status is None:
+            # Device has been claimed
+            if self._polling_task and not self._polling_task.done():
+                self._polling_task.cancel()
+                self._polling_task = None
+            return self.async_external_step_done(next_step_id="create_entry")
+
+        # Device not claimed yet, show the external step again
+        if self._polling_task and not self._polling_task.done():
+            self._polling_task.cancel()
+            self._polling_task = None
+        return self.async_external_step(
+            step_id="auth_and_claim",
+            url=claim_info.get("claim_url", ""),
+            description_placeholders=claim_info,
+        )
+
+    async def async_step_create_entry(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Final step to create the entry after successful claim."""
+        _LOGGER.debug("Creating entry with title: %s", self._flow_data["record_name"])
+        return self.async_create_entry(
+            title=self._flow_data["record_name"],
+            data=self._flow_data,
+            description="add_sensor_mapping_hint",
+            description_placeholders={"integration_name": NAME},
+        )
+
+    async def async_step_reauth(
+        self, entry_data: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Perform reauthentication upon an API authentication error."""
+        # Note: This device_id is for EnergyID's webhook system, not related to HA's device registry
+        self._flow_data = {
+            CONF_DEVICE_ID: entry_data[CONF_DEVICE_ID],
+            CONF_DEVICE_NAME: entry_data[CONF_DEVICE_NAME],
+        }
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Confirm reauthentication dialog."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            self._flow_data.update(user_input)
+            auth_status = await self._perform_auth_and_get_details()
+
+            if auth_status is None:
+                # Authentication successful and claimed
+                await self.async_set_unique_id(self._flow_data["record_number"])
+                self._abort_if_unique_id_mismatch(reason="wrong_account")
+                return self.async_update_reload_and_abort(
+                    self._get_reauth_entry(),
+                    data_updates={
+                        CONF_PROVISIONING_KEY: user_input[CONF_PROVISIONING_KEY],
+                        CONF_PROVISIONING_SECRET: user_input[CONF_PROVISIONING_SECRET],
+                    },
+                )
+
+            if auth_status == "needs_claim":
+                return await self.async_step_auth_and_claim()
+
+            errors["base"] = auth_status
+
+        return self.async_show_form(
+            step_id="reauth_confirm",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(CONF_PROVISIONING_KEY): str,
+                    vol.Required(CONF_PROVISIONING_SECRET): cv.string,
+                }
+            ),
+            errors=errors,
+            description_placeholders={
+                "docs_url": "https://app.energyid.eu/integrations/home-assistant",
+                "integration_name": NAME,
+            },
+        )
+
+    @classmethod
+    @callback
+    def async_get_supported_subentry_types(
+        cls, config_entry: ConfigEntry
+    ) -> dict[str, type[ConfigSubentryFlow]]:
+        """Return subentries supported by this integration."""
+        return {"sensor_mapping": EnergyIDSensorMappingFlowHandler}

homeassistant/components/energyid/const.py

@@ -0,0 +1,21 @@
+"""Constants for the EnergyID integration."""
+
+from typing import Final
+
+DOMAIN: Final = "energyid"
+NAME: Final = "EnergyID"
+
+# --- Config Flow and Entry Data ---
+CONF_PROVISIONING_KEY: Final = "provisioning_key"
+CONF_PROVISIONING_SECRET: Final = "provisioning_secret"
+CONF_DEVICE_ID: Final = "device_id"
+CONF_DEVICE_NAME: Final = "device_name"
+
+# --- Subentry (Mapping) Data ---
+CONF_HA_ENTITY_UUID: Final = "ha_entity_uuid"
+CONF_ENERGYID_KEY: Final = "energyid_key"
+
+# --- Webhook and Polling Configuration ---
+ENERGYID_DEVICE_ID_FOR_WEBHOOK_PREFIX: Final = "homeassistant_eid_"
+POLLING_INTERVAL: Final = 2  # seconds
+MAX_POLLING_ATTEMPTS: Final = 60  # 2 minutes total

homeassistant/components/energyid/energyid_sensor_mapping_flow.py

@@ -0,0 +1,156 @@
+"""Subentry flow for EnergyID integration, handling sensor mapping management."""
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components.sensor import SensorDeviceClass, SensorStateClass
+from homeassistant.config_entries import ConfigSubentryFlow, SubentryFlowResult
+from homeassistant.const import Platform
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.helpers import entity_registry as er
+from homeassistant.helpers.selector import EntitySelector, EntitySelectorConfig
+
+from .const import CONF_ENERGYID_KEY, CONF_HA_ENTITY_UUID, DOMAIN, NAME
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@callback
+def _get_suggested_entities(hass: HomeAssistant) -> list[str]:
+    """Return a sorted list of suggested sensor entity IDs for mapping."""
+    ent_reg = er.async_get(hass)
+    suitable_entities = []
+
+    for entity_entry in ent_reg.entities.values():
+        if not (
+            entity_entry.domain == Platform.SENSOR and entity_entry.platform != DOMAIN
+        ):
+            continue
+
+        if not hass.states.get(entity_entry.entity_id):
+            continue
+
+        state_class = (entity_entry.capabilities or {}).get("state_class")
+        has_numeric_indicators = (
+            state_class
+            in (
+                SensorStateClass.MEASUREMENT,
+                SensorStateClass.TOTAL,
+                SensorStateClass.TOTAL_INCREASING,
+            )
+            or entity_entry.device_class
+            in (
+                SensorDeviceClass.ENERGY,
+                SensorDeviceClass.GAS,
+                SensorDeviceClass.POWER,
+                SensorDeviceClass.TEMPERATURE,
+                SensorDeviceClass.VOLUME,
+            )
+            or entity_entry.original_device_class
+            in (
+                SensorDeviceClass.ENERGY,
+                SensorDeviceClass.GAS,
+                SensorDeviceClass.POWER,
+                SensorDeviceClass.TEMPERATURE,
+                SensorDeviceClass.VOLUME,
+            )
+        )
+
+        if has_numeric_indicators:
+            suitable_entities.append(entity_entry.entity_id)
+
+    return sorted(suitable_entities)
+
+
+@callback
+def _validate_mapping_input(
+    ha_entity_id: str | None,
+    current_mappings: set[str],
+    ent_reg: er.EntityRegistry,
+) -> dict[str, str]:
+    """Validate mapping input and return errors if any."""
+    errors: dict[str, str] = {}
+    if not ha_entity_id:
+        errors["base"] = "entity_required"
+        return errors
+
+    # Check if entity exists
+    entity_entry = ent_reg.async_get(ha_entity_id)
+    if not entity_entry:
+        errors["base"] = "entity_not_found"
+        return errors
+
+    # Check if entity is already mapped (by UUID)
+    entity_uuid = entity_entry.id
+    if entity_uuid in current_mappings:
+        errors["base"] = "entity_already_mapped"
+
+    return errors
+
+
+class EnergyIDSensorMappingFlowHandler(ConfigSubentryFlow):
+    """Handle EnergyID sensor mapping subentry flow for adding new mappings."""
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> SubentryFlowResult:
+        """Handle the user step for adding a new sensor mapping."""
+        errors: dict[str, str] = {}
+
+        config_entry = self._get_entry()
+        ent_reg = er.async_get(self.hass)
+
+        if user_input is not None:
+            ha_entity_id = user_input.get("ha_entity_id")
+
+            # Get current mappings by UUID
+            current_mappings = {
+                uuid
+                for sub in config_entry.subentries.values()
+                if (uuid := sub.data.get(CONF_HA_ENTITY_UUID)) is not None
+            }
+
+            errors = _validate_mapping_input(ha_entity_id, current_mappings, ent_reg)
+
+            if not errors and ha_entity_id:
+                # Get entity registry entry
+                entity_entry = ent_reg.async_get(ha_entity_id)
+                if entity_entry:
+                    energyid_key = ha_entity_id.split(".", 1)[-1]
+
+                    subentry_data = {
+                        CONF_HA_ENTITY_UUID: entity_entry.id,  # Store UUID only
+                        CONF_ENERGYID_KEY: energyid_key,
+                    }
+
+                    title = f"{ha_entity_id.split('.', 1)[-1]} connection to {NAME}"
+                    _LOGGER.debug(
+                        "Creating subentry with title='%s', data=%s",
+                        title,
+                        subentry_data,
+                    )
+                    _LOGGER.debug("Parent config entry ID: %s", config_entry.entry_id)
+                    _LOGGER.debug(
+                        "Creating subentry with parent: %s", self._get_entry().entry_id
+                    )
+                    return self.async_create_entry(title=title, data=subentry_data)
+                errors["base"] = "entity_not_found"
+
+        suggested_entities = _get_suggested_entities(self.hass)
+
+        data_schema = vol.Schema(
+            {
+                vol.Required("ha_entity_id"): EntitySelector(
+                    EntitySelectorConfig(include_entities=suggested_entities)
+                ),
+            }
+        )
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=data_schema,
+            errors=errors,
+            description_placeholders={"integration_name": NAME},
+        )

homeassistant/components/energyid/manifest.json

@@ -0,0 +1,12 @@
+{
+  "domain": "energyid",
+  "name": "EnergyID",
+  "codeowners": ["@JrtPec", "@Molier"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/energyid",
+  "integration_type": "service",
+  "iot_class": "cloud_push",
+  "loggers": ["energyid_webhooks"],
+  "quality_scale": "silver",
+  "requirements": ["energyid-webhooks==0.0.14"]
+}

homeassistant/components/energyid/quality_scale.yaml

@@ -0,0 +1,137 @@
+rules:
+  # Bronze
+  action-setup:
+    status: exempt
+    comment: The integration does not expose any custom service actions.
+  appropriate-polling:
+    status: exempt
+    comment: The integration uses a push-based mechanism with a background sync task, not polling.
+  brands:
+    status: done
+  common-modules:
+    status: done
+  config-flow-test-coverage:
+    status: done
+  config-flow:
+    status: done
+  dependency-transparency:
+    status: done
+  docs-actions:
+    status: exempt
+    comment: The integration does not expose any custom service actions.
+  docs-high-level-description:
+    status: done
+  docs-installation-instructions:
+    status: done
+  docs-removal-instructions:
+    status: done
+  entity-event-setup:
+    status: exempt
+    comment: This integration does not create its own entities.
+  entity-unique-id:
+    status: exempt
+    comment: This integration does not create its own entities.
+  has-entity-name:
+    status: exempt
+    comment: This integration does not create its own entities.
+  runtime-data:
+    status: done
+  test-before-configure:
+    status: done
+  test-before-setup:
+    status: done
+  unique-config-entry:
+    status: done
+
+  # Silver
+  action-exceptions:
+    status: exempt
+    comment: The integration does not expose any custom service actions.
+  config-entry-unloading:
+    status: done
+  docs-configuration-parameters:
+    status: done
+  docs-installation-parameters:
+    status: done
+  entity-unavailable:
+    status: exempt
+    comment: This integration does not create its own entities.
+  integration-owner:
+    status: done
+  log-when-unavailable:
+    status: done
+    comment: The integration logs a single  message when the EnergyID service is unavailable.
+  parallel-updates:
+    status: exempt
+    comment: This integration does not create its own entities.
+  reauthentication-flow:
+    status: done
+  test-coverage:
+    status: done
+
+  # Gold
+  devices:
+    status: exempt
+    comment: The integration does not create any entities, nor does it create devices.
+  diagnostics:
+    status: todo
+    comment: Diagnostics will be added in a follow-up PR to help with debugging.
+  discovery:
+    status: exempt
+    comment: Configuration requires manual entry of provisioning credentials.
+  discovery-update-info:
+    status: exempt
+    comment: No discovery mechanism is used.
+  docs-data-update:
+    status: done
+  docs-examples:
+    status: done
+  docs-known-limitations:
+    status: done
+  docs-supported-devices:
+    status: exempt
+    comment: This is a service integration not tied to specific device models.
+  docs-supported-functions:
+    status: done
+  docs-troubleshooting:
+    status: done
+  docs-use-cases:
+    status: done
+  dynamic-devices:
+    status: exempt
+    comment: The integration creates a single device entry for the service connection.
+  entity-category:
+    status: exempt
+    comment: This integration does not create its own entities.
+  entity-device-class:
+    status: exempt
+    comment: This integration does not create its own entities.
+  entity-disabled-by-default:
+    status: exempt
+    comment: This integration does not create its own entities.
+  entity-translations:
+    status: exempt
+    comment: This integration does not create its own entities.
+  exception-translations:
+    status: done
+  icon-translations:
+    status: exempt
+    comment: This integration does not create its own entities.
+  reconfiguration-flow:
+    status: todo
+    comment: Reconfiguration will be added in a follow-up PR to allow updating the device name.
+  repair-issues:
+    status: exempt
+    comment: Authentication issues are handled via the reauthentication flow.
+  stale-devices:
+    status: exempt
+    comment: Creates a single service device entry tied to the config entry.
+
+  # Platinum
+  async-dependency:
+    status: done
+  inject-websession:
+    status: done
+  strict-typing:
+    status: todo
+    comment: Full strict typing compliance will be addressed in a future update.

homeassistant/components/energyid/strings.json

@@ -0,0 +1,71 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "This device is already configured.",
+      "reauth_successful": "Reauthentication successful."
+    },
+    "create_entry": {
+      "add_sensor_mapping_hint": "You can now add mappings from any sensor in Home Assistant to {integration_name} using the '+ add sensor mapping' button."
+    },
+    "error": {
+      "cannot_connect": "Failed to connect to {integration_name} API.",
+      "claim_failed_or_timed_out": "Claiming the device failed or the code expired.",
+      "invalid_auth": "Invalid provisioning key or secret.",
+      "unknown_auth_error": "Unexpected error occurred during authentication."
+    },
+    "step": {
+      "auth_and_claim": {
+        "description": "This Home Assistant connection needs to be claimed in your {integration_name} portal before it can send data.\n\n1. Go to: {claim_url}\n2. Enter code: **{claim_code}**\n3. (Code expires: {valid_until})\n\nAfter successfully claiming the device in {integration_name}, select **Submit** below to continue.",
+        "title": "Claim device in {integration_name}"
+      },
+      "reauth_confirm": {
+        "data": {
+          "provisioning_key": "[%key:component::energyid::config::step::user::data::provisioning_key%]",
+          "provisioning_secret": "[%key:component::energyid::config::step::user::data::provisioning_secret%]"
+        },
+        "data_description": {
+          "provisioning_key": "[%key:component::energyid::config::step::user::data_description::provisioning_key%]",
+          "provisioning_secret": "[%key:component::energyid::config::step::user::data_description::provisioning_secret%]"
+        },
+        "description": "Please re-enter your {integration_name} provisioning key and secret to restore the connection.\n\nMore info: {docs_url}",
+        "title": "Reauthenticate {integration_name}"
+      },
+      "user": {
+        "data": {
+          "provisioning_key": "Provisioning key",
+          "provisioning_secret": "Provisioning secret"
+        },
+        "data_description": {
+          "provisioning_key": "Your unique key for provisioning.",
+          "provisioning_secret": "Your secret associated with the provisioning key."
+        },
+        "description": "Enter your {integration_name} webhook provisioning key and secret. Find these in your {integration_name} integration setup under provisioning credentials.\n\nMore info: {docs_url}",
+        "title": "Connect to {integration_name}"
+      }
+    }
+  },
+  "config_subentries": {
+    "sensor_mapping": {
+      "entry_type": "service",
+      "error": {
+        "entity_already_mapped": "This Home Assistant entity is already mapped.",
+        "entity_required": "You must select a sensor entity."
+      },
+      "initiate_flow": {
+        "user": "Add sensor mapping"
+      },
+      "step": {
+        "user": {
+          "data": {
+            "ha_entity_id": "Home Assistant sensor"
+          },
+          "data_description": {
+            "ha_entity_id": "Select the sensor from Home Assistant to send to {integration_name}."
+          },
+          "description": "Select a Home Assistant sensor to send to {integration_name}. The sensor name will be used as the {integration_name} metric key.",
+          "title": "Add sensor mapping"
+        }
+      }
+    }
+  }
+}

homeassistant/components/enphase_envoy/manifest.json

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

homeassistant/components/esphome/__init__.py

@@ -25,6 +25,7 @@ from .domain_data import DomainData
 from .encryption_key_storage import async_get_encryption_key_storage
 from .entry_data import ESPHomeConfigEntry, RuntimeEntryData
 from .manager import DEVICE_CONFLICT_ISSUE_FORMAT, ESPHomeManager, cleanup_instance
+from .websocket_api import async_setup as async_setup_websocket_api
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -38,6 +39,7 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
     ffmpeg_proxy.async_setup(hass)
     await assist_satellite.async_setup(hass)
     await dashboard.async_setup(hass)
+    async_setup_websocket_api(hass)
     return True
 
 

homeassistant/components/esphome/const.py

@@ -17,7 +17,7 @@ DEFAULT_NEW_CONFIG_ALLOW_ALLOW_SERVICE_CALLS = False
 
 DEFAULT_PORT: Final = 6053
 
-STABLE_BLE_VERSION_STR = "2025.8.0"
+STABLE_BLE_VERSION_STR = "2025.11.0"
 STABLE_BLE_VERSION = AwesomeVersion(STABLE_BLE_VERSION_STR)
 PROJECT_URLS = {
     "esphome.bluetooth-proxy": "https://esphome.github.io/bluetooth-proxies/",

homeassistant/components/esphome/manifest.json

@@ -17,7 +17,7 @@
   "mqtt": ["esphome/discover/#"],
   "quality_scale": "platinum",
   "requirements": [
-    "aioesphomeapi==42.8.0",
+    "aioesphomeapi==42.10.0",
     "esphome-dashboard-api==1.3.0",
     "bleak-esphome==3.4.0"
   ],

homeassistant/components/esphome/strings.json

@@ -157,7 +157,7 @@
       "title": "[%key:component::assist_pipeline::issues::assist_in_progress_deprecated::title%]"
     },
     "ble_firmware_outdated": {
-      "description": "To improve Bluetooth reliability and performance, we highly recommend updating {name} with ESPHome {version} or later. When updating the device from ESPHome earlier than 2022.12.0, it is recommended to use a serial cable instead of an over-the-air update to take advantage of the new partition scheme.",
+      "description": "ESPHome {version} introduces ultra-low latency event processing, reducing BLE event delays from 0-16 milliseconds to approximately 12 microseconds. This resolves stability issues when pairing, connecting, or handshaking with devices that require low latency, and makes Bluetooth proxy operations rival or exceed local adapters. We highly recommend updating {name} to take advantage of these improvements.",
       "title": "Update {name} with ESPHome {version} or later"
     },
     "device_conflict": {

homeassistant/components/esphome/websocket_api.py

@@ -0,0 +1,52 @@
+"""ESPHome websocket API."""
+
+import logging
+from typing import Any
+
+import voluptuous as vol
+
+from homeassistant.components import websocket_api
+from homeassistant.core import HomeAssistant, callback
+
+from .const import CONF_NOISE_PSK
+
+_LOGGER = logging.getLogger(__name__)
+
+
+TYPE = "type"
+ENTRY_ID = "entry_id"
+
+
+@callback
+def async_setup(hass: HomeAssistant) -> None:
+    """Set up the websocket API."""
+    websocket_api.async_register_command(hass, get_encryption_key)
+
+
+@callback
+@websocket_api.require_admin
+@websocket_api.websocket_command(
+    {
+        vol.Required(TYPE): "esphome/get_encryption_key",
+        vol.Required(ENTRY_ID): str,
+    }
+)
+def get_encryption_key(
+    hass: HomeAssistant,
+    connection: websocket_api.connection.ActiveConnection,
+    msg: dict[str, Any],
+) -> None:
+    """Get the encryption key for an ESPHome config entry."""
+    entry = hass.config_entries.async_get_entry(msg[ENTRY_ID])
+    if entry is None:
+        connection.send_error(
+            msg["id"], websocket_api.ERR_NOT_FOUND, "Config entry not found"
+        )
+        return
+
+    connection.send_result(
+        msg["id"],
+        {
+            "encryption_key": entry.data.get(CONF_NOISE_PSK),
+        },
+    )

homeassistant/components/essent/sensor.py

@@ -102,6 +102,7 @@ SENSORS: tuple[EssentSensorEntityDescription, ...] = (
         key="average_today",
         translation_key="average_today",
         value_fn=lambda energy_data: energy_data.avg_price,
+        energy_types=(EnergyType.ELECTRICITY,),
     ),
     EssentSensorEntityDescription(
         key="lowest_price_today",

homeassistant/components/essent/strings.json

@@ -44,9 +44,6 @@
       "electricity_next_price": {
         "name": "Next electricity price"
       },
-      "gas_average_today": {
-        "name": "Average gas price today"
-      },
       "gas_current_price": {
         "name": "Current gas price"
       },

homeassistant/components/fan/strings.json

@@ -166,26 +166,24 @@
   "title": "Fan",
   "triggers": {
     "turned_off": {
-      "description": "Triggers when a fan is turned off.",
-      "description_configured": "[%key:component::fan::triggers::turned_off::description%]",
+      "description": "Triggers after one or more fans turn off.",
       "fields": {
         "behavior": {
           "description": "[%key:component::fan::common::trigger_behavior_description%]",
           "name": "[%key:component::fan::common::trigger_behavior_name%]"
         }
       },
-      "name": "When a fan is turned off"
+      "name": "Fan turned off"
     },
     "turned_on": {
-      "description": "Triggers when a fan is turned on.",
-      "description_configured": "[%key:component::fan::triggers::turned_on::description%]",
+      "description": "Triggers after one or more fans turn on.",
       "fields": {
         "behavior": {
           "description": "[%key:component::fan::common::trigger_behavior_description%]",
           "name": "[%key:component::fan::common::trigger_behavior_name%]"
         }
       },
-      "name": "When a fan is turned on"
+      "name": "Fan turned on"
     }
   }
 }

homeassistant/components/fitbit/api.py

@@ -1,22 +1,30 @@
 """API for fitbit bound to Home Assistant OAuth."""
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable
+from collections.abc import Awaitable, Callable
 import logging
 from typing import Any, cast
 
 from fitbit import Fitbit
 from fitbit.exceptions import HTTPException, HTTPUnauthorized
+from fitbit_web_api import ApiClient, Configuration, DevicesApi
+from fitbit_web_api.exceptions import (
+    ApiException,
+    OpenApiException,
+    UnauthorizedException,
+)
+from fitbit_web_api.models.device import Device
 from requests.exceptions import ConnectionError as RequestsConnectionError
 
 from homeassistant.const import CONF_ACCESS_TOKEN
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import config_entry_oauth2_flow
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
 from homeassistant.util.unit_system import METRIC_SYSTEM
 
 from .const import FitbitUnitSystem
 from .exceptions import FitbitApiException, FitbitAuthException
-from .model import FitbitDevice, FitbitProfile
+from .model import FitbitProfile
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -58,6 +66,14 @@ class FitbitApi(ABC):
             expires_at=float(token[CONF_EXPIRES_AT]),
         )
 
+    async def _async_get_fitbit_web_api(self) -> ApiClient:
+        """Create and return an ApiClient configured with the current access token."""
+        token = await self.async_get_access_token()
+        configuration = Configuration()
+        configuration.pool_manager = async_get_clientsession(self._hass)
+        configuration.access_token = token[CONF_ACCESS_TOKEN]
+        return ApiClient(configuration)
+
     async def async_get_user_profile(self) -> FitbitProfile:
         """Return the user profile from the API."""
         if self._profile is None:
@@ -94,21 +110,13 @@ class FitbitApi(ABC):
             return FitbitUnitSystem.METRIC
         return FitbitUnitSystem.EN_US
 
-    async def async_get_devices(self) -> list[FitbitDevice]:
-        """Return available devices."""
-        client = await self._async_get_client()
-        devices: list[dict[str, str]] = await self._run(client.get_devices)
+    async def async_get_devices(self) -> list[Device]:
+        """Return available devices using fitbit-web-api."""
+        client = await self._async_get_fitbit_web_api()
+        devices_api = DevicesApi(client)
+        devices: list[Device] = await self._run_async(devices_api.get_devices)
         _LOGGER.debug("get_devices=%s", devices)
-        return [
-            FitbitDevice(
-                id=device["id"],
-                device_version=device["deviceVersion"],
-                battery_level=int(device["batteryLevel"]),
-                battery=device["battery"],
-                type=device["type"],
-            )
-            for device in devices
-        ]
+        return devices
 
     async def async_get_latest_time_series(self, resource_type: str) -> dict[str, Any]:
         """Return the most recent value from the time series for the specified resource type."""
@@ -140,6 +148,20 @@ class FitbitApi(ABC):
             _LOGGER.debug("Error from fitbit API: %s", err)
             raise FitbitApiException("Error from fitbit API") from err
 
+    async def _run_async[_T](self, func: Callable[[], Awaitable[_T]]) -> _T:
+        """Run client command."""
+        try:
+            return await func()
+        except UnauthorizedException as err:
+            _LOGGER.debug("Unauthorized error from fitbit API: %s", err)
+            raise FitbitAuthException("Authentication error from fitbit API") from err
+        except ApiException as err:
+            _LOGGER.debug("Error from fitbit API: %s", err)
+            raise FitbitApiException("Error from fitbit API") from err
+        except OpenApiException as err:
+            _LOGGER.debug("Error communicating with fitbit API: %s", err)
+            raise FitbitApiException("Communication error from fitbit API") from err
+
 
 class OAuthFitbitApi(FitbitApi):
     """Provide fitbit authentication tied to an OAuth2 based config entry."""