Adjust

Simplify
2026-05-04 11:54:35 +02:00 · 2025-12-11 12:02:41 +00:00 · 2025-12-11 11:59:58 +00:00 · 2025-12-11 11:02:08 +00:00 · 2025-12-11 10:59:40 +00:00 · 2025-12-11 10:28:33 +00:00
1001 changed files with 55838 additions and 15172 deletions
@@ -13,6 +13,7 @@ core: &core

 # Our base platforms, that are used by other integrations
 base_platforms: &base_platforms
+  - homeassistant/components/ai_task/**
  - homeassistant/components/air_quality/**
  - homeassistant/components/alarm_control_panel/**
  - homeassistant/components/assist_satellite/**
@@ -27,7 +27,6 @@
        "charliermarsh.ruff",
        "ms-python.pylint",
        "ms-python.vscode-pylance",
-        "visualstudioexptteam.vscodeintellicode",
        "redhat.vscode-yaml",
        "esbenp.prettier-vscode",
        "GitHub.vscode-pull-request-github",
@@ -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
@@ -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.11"
+  ALL_PYTHON_VERSIONS: "['3.13.11', '3.14.2']"
  # 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: |
@@ -1188,7 +1188,7 @@ jobs:
          pattern: coverage-*
      - name: Upload coverage to Codecov
        if: needs.info.outputs.test_full_suite == 'true'
-        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
        with:
          fail_ci_if_error: true
          flags: full-suite
@@ -1313,7 +1313,7 @@ jobs:
          pattern: coverage-*
      - name: Upload coverage to Codecov
        if: needs.info.outputs.test_full_suite == 'false'
-        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1
+        uses: codecov/codecov-action@671740ac38dd9b0130fbe1cec585b89eea48d3de # v5.5.2
        with:
          fail_ci_if_error: true
          token: ${{ secrets.CODECOV_TOKEN }}
@@ -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@cf1bb45a277cb3c205638b2cd5c984db1c46a412 # v4.31.7
        with:
          languages: python

      - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@fdbfb4d2750291e159f0156def62b853c2798ca2 # v4.31.5
+        uses: github/codeql-action/analyze@cf1bb45a277cb3c205638b2cd5c984db1c46a412 # v4.31.7
        with:
          category: "/language:python"
@@ -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: |
@@ -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: |
@@ -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"
@@ -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
@@ -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
@@ -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.*
@@ -73,6 +73,8 @@ build.json @home-assistant/supervisor
 /tests/components/airobot/ @mettolen
 /homeassistant/components/airos/ @CoMPaTech
 /tests/components/airos/ @CoMPaTech
+/homeassistant/components/airpatrol/ @antondalgren
+/tests/components/airpatrol/ @antondalgren
 /homeassistant/components/airq/ @Sibgatulin @dl2080
 /tests/components/airq/ @Sibgatulin @dl2080
 /homeassistant/components/airthings/ @danielhiversen @LaStrada
@@ -418,6 +420,8 @@ build.json @home-assistant/supervisor
 /homeassistant/components/efergy/ @tkdrob
 /tests/components/efergy/ @tkdrob
 /homeassistant/components/egardia/ @jeroenterheerdt
+/homeassistant/components/egauge/ @neggert
+/tests/components/egauge/ @neggert
 /homeassistant/components/eheimdigital/ @autinerd
 /tests/components/eheimdigital/ @autinerd
 /homeassistant/components/ekeybionyx/ @richardpolzer
@@ -452,13 +456,15 @@ 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
 /tests/components/enigma2/ @autinerd
 /homeassistant/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
 /tests/components/enphase_envoy/ @bdraco @cgarwood @catsmanac
-/homeassistant/components/entur_public_transport/ @hfurubotten
+/homeassistant/components/entur_public_transport/ @hfurubotten @SanderBlom
 /homeassistant/components/environment_canada/ @gwww @michaeldavie
 /tests/components/environment_canada/ @gwww @michaeldavie
 /homeassistant/components/ephember/ @ttroy50 @roberty99
@@ -537,6 +543,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
@@ -567,6 +575,8 @@ build.json @home-assistant/supervisor
 /tests/components/generic_hygrostat/ @Shulyaka
 /homeassistant/components/geniushub/ @manzanotti
 /tests/components/geniushub/ @manzanotti
+/homeassistant/components/gentex_homelink/ @niaexa @ryanjones-gentex
+/tests/components/gentex_homelink/ @niaexa @ryanjones-gentex
 /homeassistant/components/geo_json_events/ @exxamalte
 /tests/components/geo_json_events/ @exxamalte
 /homeassistant/components/geo_location/ @home-assistant/core
@@ -1352,8 +1362,8 @@ build.json @home-assistant/supervisor
 /tests/components/ring/ @sdb9696
 /homeassistant/components/risco/ @OnFreund
 /tests/components/risco/ @OnFreund
-/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck
-/tests/components/rituals_perfume_genie/ @milanmeu @frenck
+/homeassistant/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
+/tests/components/rituals_perfume_genie/ @milanmeu @frenck @quebulm
 /homeassistant/components/rmvtransport/ @cgtobi
 /tests/components/rmvtransport/ @cgtobi
 /homeassistant/components/roborock/ @Lash-L @allenporter
@@ -1759,6 +1769,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
@@ -1798,6 +1809,8 @@ build.json @home-assistant/supervisor
 /tests/components/weatherflow_cloud/ @jeeftor
 /homeassistant/components/weatherkit/ @tjhorner
 /tests/components/weatherkit/ @tjhorner
+/homeassistant/components/web_rtc/ @home-assistant/core
+/tests/components/web_rtc/ @home-assistant/core
 /homeassistant/components/webdav/ @jpbede
 /tests/components/webdav/ @jpbede
 /homeassistant/components/webhook/ @home-assistant/core
@@ -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

@@ -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,
 }
@@ -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,
            )

@@ -101,8 +101,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                    vol.Schema({str: STRUCTURE_FIELD_SCHEMA}),
                    _validate_structure_fields,
                ),
-                vol.Optional(ATTR_ATTACHMENTS): vol.All(
-                    cv.ensure_list, [selector.MediaSelector({"accept": ["*/*"]})]
+                vol.Optional(ATTR_ATTACHMENTS): selector.MediaSelector(
+                    {"accept": ["*/*"], "multiple": True}
                ),
            }
        ),
@@ -118,8 +118,8 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
                vol.Required(ATTR_TASK_NAME): cv.string,
                vol.Optional(ATTR_ENTITY_ID): cv.entity_id,
                vol.Required(ATTR_INSTRUCTIONS): cv.string,
-                vol.Optional(ATTR_ATTACHMENTS): vol.All(
-                    cv.ensure_list, [selector.MediaSelector({"accept": ["*/*"]})]
+                vol.Optional(ATTR_ATTACHMENTS): selector.MediaSelector(
+                    {"accept": ["*/*"], "multiple": True}
                ),
            }
        ),
@@ -7,7 +7,7 @@ from homeassistant.core import HomeAssistant

 from .coordinator import AirobotConfigEntry, AirobotDataUpdateCoordinator

-PLATFORMS: list[Platform] = [Platform.CLIMATE]
+PLATFORMS: list[Platform] = [Platform.CLIMATE, Platform.SENSOR]


 async def async_setup_entry(hass: HomeAssistant, entry: AirobotConfigEntry) -> bool:
@@ -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."""
@@ -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)
@@ -0,0 +1,38 @@
+"""Diagnostics support for Airobot."""
+
+from __future__ import annotations
+
+from dataclasses import asdict
+from typing import Any
+
+from homeassistant.components.diagnostics import async_redact_data
+from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME
+from homeassistant.core import HomeAssistant
+
+from .coordinator import AirobotConfigEntry
+
+TO_REDACT_CONFIG = [CONF_HOST, CONF_MAC, CONF_PASSWORD, CONF_USERNAME]
+
+
+async def async_get_config_entry_diagnostics(
+    hass: HomeAssistant, entry: AirobotConfigEntry
+) -> dict[str, Any]:
+    """Return diagnostics for a config entry."""
+    coordinator = entry.runtime_data
+
+    # Build device capabilities info
+    device_capabilities = None
+    if coordinator.data:
+        device_capabilities = {
+            "has_floor_sensor": coordinator.data.status.has_floor_sensor,
+            "has_co2_sensor": coordinator.data.status.has_co2_sensor,
+            "hw_version": coordinator.data.status.hw_version,
+            "fw_version": coordinator.data.status.fw_version,
+        }
+
+    return {
+        "entry_data": async_redact_data(entry.data, TO_REDACT_CONFIG),
+        "device_capabilities": device_capabilities,
+        "status": asdict(coordinator.data.status) if coordinator.data else None,
+        "settings": asdict(coordinator.data.settings) if coordinator.data else None,
+    }
@@ -12,6 +12,6 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["pyairobotrest"],
-  "quality_scale": "bronze",
+  "quality_scale": "silver",
  "requirements": ["pyairobotrest==0.1.0"]
 }
@@ -34,17 +34,17 @@ rules:
  integration-owner: done
  log-when-unavailable: done
  parallel-updates: done
-  reauthentication-flow: todo
+  reauthentication-flow: done
  test-coverage: done

  # Gold
  devices: done
-  diagnostics: todo
+  diagnostics: done
  discovery-update-info: done
  discovery: done
  docs-data-update: done
  docs-examples: todo
-  docs-known-limitations: todo
+  docs-known-limitations: done
  docs-supported-devices: done
  docs-supported-functions: done
  docs-troubleshooting: done
@@ -54,8 +54,8 @@ rules:
    comment: Single device integration, no dynamic device discovery needed.
  entity-category: done
  entity-device-class: done
-  entity-disabled-by-default: todo
-  entity-translations: todo
+  entity-disabled-by-default: done
+  entity-translations: done
  exception-translations: done
  icon-translations: todo
  reconfiguration-flow: todo
@@ -0,0 +1,134 @@
+"""Sensor platform for Airobot thermostat."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from pyairobotrest.models import ThermostatStatus
+
+from homeassistant.components.sensor import (
+    SensorDeviceClass,
+    SensorEntity,
+    SensorEntityDescription,
+    SensorStateClass,
+)
+from homeassistant.const import (
+    CONCENTRATION_PARTS_PER_MILLION,
+    PERCENTAGE,
+    EntityCategory,
+    UnitOfTemperature,
+    UnitOfTime,
+)
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+from homeassistant.helpers.typing import StateType
+
+from . import AirobotConfigEntry
+from .entity import AirobotEntity
+
+PARALLEL_UPDATES = 0
+
+
+@dataclass(frozen=True, kw_only=True)
+class AirobotSensorEntityDescription(SensorEntityDescription):
+    """Describes Airobot sensor entity."""
+
+    value_fn: Callable[[ThermostatStatus], StateType]
+    supported_fn: Callable[[ThermostatStatus], bool] = lambda _: True
+
+
+SENSOR_TYPES: tuple[AirobotSensorEntityDescription, ...] = (
+    AirobotSensorEntityDescription(
+        key="air_temperature",
+        translation_key="air_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.temp_air,
+    ),
+    AirobotSensorEntityDescription(
+        key="humidity",
+        device_class=SensorDeviceClass.HUMIDITY,
+        native_unit_of_measurement=PERCENTAGE,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.hum_air,
+    ),
+    AirobotSensorEntityDescription(
+        key="floor_temperature",
+        translation_key="floor_temperature",
+        device_class=SensorDeviceClass.TEMPERATURE,
+        native_unit_of_measurement=UnitOfTemperature.CELSIUS,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.temp_floor,
+        supported_fn=lambda status: status.has_floor_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="co2",
+        device_class=SensorDeviceClass.CO2,
+        native_unit_of_measurement=CONCENTRATION_PARTS_PER_MILLION,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.co2,
+        supported_fn=lambda status: status.has_co2_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="air_quality_index",
+        device_class=SensorDeviceClass.AQI,
+        state_class=SensorStateClass.MEASUREMENT,
+        value_fn=lambda status: status.aqi,
+        supported_fn=lambda status: status.has_co2_sensor,
+    ),
+    AirobotSensorEntityDescription(
+        key="heating_uptime",
+        translation_key="heating_uptime",
+        device_class=SensorDeviceClass.DURATION,
+        native_unit_of_measurement=UnitOfTime.SECONDS,
+        suggested_unit_of_measurement=UnitOfTime.HOURS,
+        state_class=SensorStateClass.TOTAL_INCREASING,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda status: status.heating_uptime,
+        entity_registry_enabled_default=False,
+    ),
+    AirobotSensorEntityDescription(
+        key="errors",
+        translation_key="errors",
+        state_class=SensorStateClass.MEASUREMENT,
+        entity_category=EntityCategory.DIAGNOSTIC,
+        value_fn=lambda status: status.errors,
+    ),
+)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry: AirobotConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up Airobot sensor platform."""
+    coordinator = entry.runtime_data
+    async_add_entities(
+        AirobotSensor(coordinator, description)
+        for description in SENSOR_TYPES
+        if description.supported_fn(coordinator.data.status)
+    )
+
+
+class AirobotSensor(AirobotEntity, SensorEntity):
+    """Representation of an Airobot sensor."""
+
+    entity_description: AirobotSensorEntityDescription
+
+    def __init__(
+        self,
+        coordinator,
+        description: AirobotSensorEntityDescription,
+    ) -> None:
+        """Initialize the sensor."""
+        super().__init__(coordinator)
+        self.entity_description = description
+        self._attr_unique_id = f"{coordinator.data.status.device_id}_{description.key}"
+
+    @property
+    def native_value(self) -> StateType:
+        """Return the state of the sensor."""
+        return self.entity_description.value_fn(self.coordinator.data.status)
@@ -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.",
@@ -33,7 +43,32 @@
      }
    }
  },
+  "entity": {
+    "sensor": {
+      "air_temperature": {
+        "name": "Air temperature"
+      },
+      "device_uptime": {
+        "name": "Device uptime"
+      },
+      "errors": {
+        "name": "Error count"
+      },
+      "floor_temperature": {
+        "name": "Floor temperature"
+      },
+      "heating_uptime": {
+        "name": "Heating uptime"
+      }
+    }
+  },
  "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}."
    },
@@ -0,0 +1,24 @@
+"""The AirPatrol integration."""
+
+from __future__ import annotations
+
+from homeassistant.core import HomeAssistant
+
+from .const import PLATFORMS
+from .coordinator import AirPatrolConfigEntry, AirPatrolDataUpdateCoordinator
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: AirPatrolConfigEntry) -> bool:
+    """Set up AirPatrol from a config entry."""
+    coordinator = AirPatrolDataUpdateCoordinator(hass, entry)
+
+    await coordinator.async_config_entry_first_refresh()
+    entry.runtime_data = coordinator
+
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: AirPatrolConfigEntry) -> bool:
+    """Unload a config entry."""
+    return await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
@@ -0,0 +1,208 @@
+"""Climate platform for AirPatrol integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.components.climate import (
+    FAN_AUTO,
+    FAN_HIGH,
+    FAN_LOW,
+    SWING_OFF,
+    SWING_ON,
+    ClimateEntity,
+    ClimateEntityFeature,
+    HVACMode,
+)
+from homeassistant.const import ATTR_TEMPERATURE, UnitOfTemperature
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
+
+from . import AirPatrolConfigEntry
+from .coordinator import AirPatrolDataUpdateCoordinator
+from .entity import AirPatrolEntity
+
+PARALLEL_UPDATES = 0
+
+AP_TO_HA_HVAC_MODES = {
+    "heat": HVACMode.HEAT,
+    "cool": HVACMode.COOL,
+    "off": HVACMode.OFF,
+}
+HA_TO_AP_HVAC_MODES = {value: key for key, value in AP_TO_HA_HVAC_MODES.items()}
+
+AP_TO_HA_FAN_MODES = {
+    "min": FAN_LOW,
+    "max": FAN_HIGH,
+    "auto": FAN_AUTO,
+}
+HA_TO_AP_FAN_MODES = {value: key for key, value in AP_TO_HA_FAN_MODES.items()}
+
+AP_TO_HA_SWING_MODES = {
+    "on": SWING_ON,
+    "off": SWING_OFF,
+}
+HA_TO_AP_SWING_MODES = {value: key for key, value in AP_TO_HA_SWING_MODES.items()}
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    config_entry: AirPatrolConfigEntry,
+    async_add_entities: AddConfigEntryEntitiesCallback,
+) -> None:
+    """Set up AirPatrol climate entities."""
+    coordinator = config_entry.runtime_data
+    units = coordinator.data
+
+    async_add_entities(
+        AirPatrolClimate(coordinator, unit_id)
+        for unit_id, unit in units.items()
+        if "climate" in unit
+    )
+
+
+class AirPatrolClimate(AirPatrolEntity, ClimateEntity):
+    """AirPatrol climate entity."""
+
+    _attr_name = None
+    _attr_temperature_unit = UnitOfTemperature.CELSIUS
+    _attr_supported_features = (
+        ClimateEntityFeature.TARGET_TEMPERATURE
+        | ClimateEntityFeature.FAN_MODE
+        | ClimateEntityFeature.SWING_MODE
+        | ClimateEntityFeature.TURN_OFF
+        | ClimateEntityFeature.TURN_ON
+    )
+    _attr_hvac_modes = [HVACMode.HEAT, HVACMode.COOL, HVACMode.OFF]
+    _attr_fan_modes = [FAN_LOW, FAN_HIGH, FAN_AUTO]
+    _attr_swing_modes = [SWING_ON, SWING_OFF]
+    _attr_min_temp = 16.0
+    _attr_max_temp = 30.0
+
+    def __init__(
+        self,
+        coordinator: AirPatrolDataUpdateCoordinator,
+        unit_id: str,
+    ) -> None:
+        """Initialize the climate entity."""
+        super().__init__(coordinator, unit_id)
+        self._attr_unique_id = f"{coordinator.config_entry.unique_id}-{unit_id}"
+
+    @property
+    def climate_data(self) -> dict[str, Any]:
+        """Return the climate data."""
+        return self.device_data.get("climate") or {}
+
+    @property
+    def params(self) -> dict[str, Any]:
+        """Return the current parameters for the climate entity."""
+        return self.climate_data.get("ParametersData") or {}
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and bool(self.climate_data)
+
+    @property
+    def current_humidity(self) -> float | None:
+        """Return the current humidity."""
+        if humidity := self.climate_data.get("RoomHumidity"):
+            return float(humidity)
+        return None
+
+    @property
+    def current_temperature(self) -> float | None:
+        """Return the current temperature."""
+        if temp := self.climate_data.get("RoomTemp"):
+            return float(temp)
+        return None
+
+    @property
+    def target_temperature(self) -> float | None:
+        """Return the target temperature."""
+        if temp := self.params.get("PumpTemp"):
+            return float(temp)
+        return None
+
+    @property
+    def hvac_mode(self) -> HVACMode | None:
+        """Return the current HVAC mode."""
+        pump_power = self.params.get("PumpPower")
+        pump_mode = self.params.get("PumpMode")
+
+        if pump_power and pump_power == "on" and pump_mode:
+            return AP_TO_HA_HVAC_MODES.get(pump_mode)
+        return HVACMode.OFF
+
+    @property
+    def fan_mode(self) -> str | None:
+        """Return the current fan mode."""
+        fan_speed = self.params.get("FanSpeed")
+        if fan_speed:
+            return AP_TO_HA_FAN_MODES.get(fan_speed)
+        return None
+
+    @property
+    def swing_mode(self) -> str | None:
+        """Return the current swing mode."""
+        swing = self.params.get("Swing")
+        if swing:
+            return AP_TO_HA_SWING_MODES.get(swing)
+        return None
+
+    async def async_set_temperature(self, **kwargs: Any) -> None:
+        """Set new target temperature."""
+        params = self.params.copy()
+
+        if ATTR_TEMPERATURE in kwargs:
+            temp = kwargs[ATTR_TEMPERATURE]
+            params["PumpTemp"] = f"{temp:.3f}"
+
+        await self._async_set_params(params)
+
+    async def async_set_hvac_mode(self, hvac_mode: HVACMode) -> None:
+        """Set new target hvac mode."""
+        params = self.params.copy()
+
+        if hvac_mode == HVACMode.OFF:
+            params["PumpPower"] = "off"
+        else:
+            params["PumpPower"] = "on"
+            params["PumpMode"] = HA_TO_AP_HVAC_MODES.get(hvac_mode)
+
+        await self._async_set_params(params)
+
+    async def async_set_fan_mode(self, fan_mode: str) -> None:
+        """Set new target fan mode."""
+        params = self.params.copy()
+        params["FanSpeed"] = HA_TO_AP_FAN_MODES.get(fan_mode)
+
+        await self._async_set_params(params)
+
+    async def async_set_swing_mode(self, swing_mode: str) -> None:
+        """Set new target swing mode."""
+        params = self.params.copy()
+        params["Swing"] = HA_TO_AP_SWING_MODES.get(swing_mode)
+
+        await self._async_set_params(params)
+
+    async def async_turn_on(self) -> None:
+        """Turn the entity on."""
+        params = self.params.copy()
+        if mode := AP_TO_HA_HVAC_MODES.get(params["PumpMode"]):
+            await self.async_set_hvac_mode(mode)
+
+    async def async_turn_off(self) -> None:
+        """Turn the entity off."""
+        await self.async_set_hvac_mode(HVACMode.OFF)
+
+    async def _async_set_params(self, params: dict[str, Any]) -> None:
+        """Set the unit to dry mode."""
+        new_climate_data = self.climate_data.copy()
+        new_climate_data["ParametersData"] = params
+
+        await self.coordinator.api.set_unit_climate_data(
+            self._unit_id, new_climate_data
+        )
+
+        await self.coordinator.async_request_refresh()
@@ -0,0 +1,111 @@
+"""Config flow for the AirPatrol integration."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any
+
+from airpatrol.api import AirPatrolAPI, AirPatrolAuthenticationError, AirPatrolError
+import voluptuous as vol
+
+from homeassistant.config_entries import ConfigFlow, ConfigFlowResult
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.selector import (
+    TextSelector,
+    TextSelectorConfig,
+    TextSelectorType,
+)
+
+from .const import DOMAIN
+
+DATA_SCHEMA = vol.Schema(
+    {
+        vol.Required(CONF_EMAIL): TextSelector(
+            TextSelectorConfig(
+                type=TextSelectorType.EMAIL,
+                autocomplete="email",
+            )
+        ),
+        vol.Required(CONF_PASSWORD): TextSelector(
+            TextSelectorConfig(
+                type=TextSelectorType.PASSWORD,
+                autocomplete="current-password",
+            )
+        ),
+    }
+)
+
+
+async def validate_api(
+    hass: HomeAssistant, user_input: dict[str, str]
+) -> tuple[str | None, str | None, dict[str, str]]:
+    """Validate the API connection."""
+    errors: dict[str, str] = {}
+    session = async_get_clientsession(hass)
+    access_token = None
+    unique_id = None
+    try:
+        api = await AirPatrolAPI.authenticate(
+            session, user_input[CONF_EMAIL], user_input[CONF_PASSWORD]
+        )
+    except AirPatrolAuthenticationError:
+        errors["base"] = "invalid_auth"
+    except AirPatrolError:
+        errors["base"] = "cannot_connect"
+    else:
+        access_token = api.get_access_token()
+        unique_id = api.get_unique_id()
+
+    return (access_token, unique_id, errors)
+
+
+class AirPatrolConfigFlow(ConfigFlow, domain=DOMAIN):
+    """Handle a config flow for AirPatrol."""
+
+    VERSION = 1
+
+    async def async_step_user(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle the initial step."""
+        errors: dict[str, str] = {}
+        if user_input is not None:
+            access_token, unique_id, errors = await validate_api(self.hass, user_input)
+            if access_token and unique_id:
+                user_input[CONF_ACCESS_TOKEN] = access_token
+                await self.async_set_unique_id(unique_id)
+                self._abort_if_unique_id_configured()
+                return self.async_create_entry(
+                    title=user_input[CONF_EMAIL], data=user_input
+                )
+
+        return self.async_show_form(
+            step_id="user", data_schema=DATA_SCHEMA, errors=errors
+        )
+
+    async def async_step_reauth(
+        self, user_input: Mapping[str, Any]
+    ) -> ConfigFlowResult:
+        """Handle reauthentication with new credentials."""
+        return await self.async_step_reauth_confirm()
+
+    async def async_step_reauth_confirm(
+        self, user_input: dict[str, Any] | None = None
+    ) -> ConfigFlowResult:
+        """Handle reauthentication confirmation."""
+        errors: dict[str, str] = {}
+
+        if user_input:
+            access_token, unique_id, errors = await validate_api(self.hass, user_input)
+            if access_token and unique_id:
+                await self.async_set_unique_id(unique_id)
+                self._abort_if_unique_id_mismatch()
+                user_input[CONF_ACCESS_TOKEN] = access_token
+                return self.async_update_reload_and_abort(
+                    self._get_reauth_entry(), data_updates=user_input
+                )
+        return self.async_show_form(
+            step_id="reauth_confirm", data_schema=DATA_SCHEMA, errors=errors
+        )
@@ -0,0 +1,16 @@
+"""Constants for the AirPatrol integration."""
+
+from datetime import timedelta
+import logging
+
+from airpatrol.api import AirPatrolAuthenticationError, AirPatrolError
+
+from homeassistant.const import Platform
+
+DOMAIN = "airpatrol"
+
+LOGGER = logging.getLogger(__package__)
+PLATFORMS = [Platform.CLIMATE]
+SCAN_INTERVAL = timedelta(minutes=1)
+
+AIRPATROL_ERRORS = (AirPatrolAuthenticationError, AirPatrolError)
@@ -0,0 +1,100 @@
+"""Data update coordinator for AirPatrol."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from airpatrol.api import AirPatrolAPI, AirPatrolAuthenticationError, AirPatrolError
+
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import CONF_ACCESS_TOKEN, CONF_EMAIL, CONF_PASSWORD
+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
+
+from .const import DOMAIN, LOGGER, SCAN_INTERVAL
+
+type AirPatrolConfigEntry = ConfigEntry[AirPatrolDataUpdateCoordinator]
+
+
+class AirPatrolDataUpdateCoordinator(DataUpdateCoordinator[dict[str, dict[str, Any]]]):
+    """Class to manage fetching AirPatrol data."""
+
+    config_entry: AirPatrolConfigEntry
+    api: AirPatrolAPI
+
+    def __init__(self, hass: HomeAssistant, config_entry: AirPatrolConfigEntry) -> None:
+        """Initialize."""
+
+        super().__init__(
+            hass,
+            LOGGER,
+            name=f"{DOMAIN.capitalize()} {config_entry.title}",
+            update_interval=SCAN_INTERVAL,
+            config_entry=config_entry,
+        )
+
+    async def _async_setup(self) -> None:
+        try:
+            await self._setup_client()
+        except AirPatrolError as api_err:
+            raise UpdateFailed(
+                f"Error communicating with AirPatrol API: {api_err}"
+            ) from api_err
+
+    async def _async_update_data(self) -> dict[str, dict[str, Any]]:
+        """Update unit data from AirPatrol API."""
+        return {unit_data["unit_id"]: unit_data for unit_data in await self._get_data()}
+
+    async def _get_data(self, retry: bool = False) -> list[dict[str, Any]]:
+        """Fetch data from API."""
+        try:
+            return await self.api.get_data()
+        except AirPatrolAuthenticationError as auth_err:
+            if retry:
+                raise ConfigEntryAuthFailed(
+                    "Authentication with AirPatrol failed"
+                ) from auth_err
+            await self._update_token()
+            return await self._get_data(retry=True)
+        except AirPatrolError as err:
+            raise UpdateFailed(
+                f"Error communicating with AirPatrol API: {err}"
+            ) from err
+
+    async def _update_token(self) -> None:
+        """Refresh the AirPatrol API client and update the access token."""
+        session = async_get_clientsession(self.hass)
+        try:
+            self.api = await AirPatrolAPI.authenticate(
+                session,
+                self.config_entry.data[CONF_EMAIL],
+                self.config_entry.data[CONF_PASSWORD],
+            )
+        except AirPatrolAuthenticationError as auth_err:
+            raise ConfigEntryAuthFailed(
+                "Authentication with AirPatrol failed"
+            ) from auth_err
+
+        self.hass.config_entries.async_update_entry(
+            self.config_entry,
+            data={
+                **self.config_entry.data,
+                CONF_ACCESS_TOKEN: self.api.get_access_token(),
+            },
+        )
+
+    async def _setup_client(self) -> None:
+        """Set up the AirPatrol API client from stored access_token."""
+        session = async_get_clientsession(self.hass)
+        api = AirPatrolAPI(
+            session,
+            self.config_entry.data[CONF_ACCESS_TOKEN],
+            self.config_entry.unique_id,
+        )
+        try:
+            await api.get_data()
+        except AirPatrolAuthenticationError:
+            await self._update_token()
+        self.api = api
@@ -0,0 +1,44 @@
+"""Base entity for AirPatrol integration."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from homeassistant.helpers.device_registry import DeviceInfo
+from homeassistant.helpers.update_coordinator import CoordinatorEntity
+
+from .const import DOMAIN
+from .coordinator import AirPatrolDataUpdateCoordinator
+
+
+class AirPatrolEntity(CoordinatorEntity[AirPatrolDataUpdateCoordinator]):
+    """Base entity for AirPatrol devices."""
+
+    _attr_has_entity_name = True
+
+    def __init__(
+        self,
+        coordinator: AirPatrolDataUpdateCoordinator,
+        unit_id: str,
+    ) -> None:
+        """Initialize the AirPatrol entity."""
+        super().__init__(coordinator)
+        self._unit_id = unit_id
+        device = coordinator.data[unit_id]
+        self._attr_device_info = DeviceInfo(
+            identifiers={(DOMAIN, unit_id)},
+            name=device["name"],
+            manufacturer=device["manufacturer"],
+            model=device["model"],
+            serial_number=device["hwid"],
+        )
+
+    @property
+    def device_data(self) -> dict[str, Any]:
+        """Return the device data."""
+        return self.coordinator.data[self._unit_id]
+
+    @property
+    def available(self) -> bool:
+        """Return if entity is available."""
+        return super().available and self._unit_id in self.coordinator.data
@@ -0,0 +1,11 @@
+{
+  "domain": "airpatrol",
+  "name": "AirPatrol",
+  "codeowners": ["@antondalgren"],
+  "config_flow": true,
+  "documentation": "https://www.home-assistant.io/integrations/airpatrol",
+  "integration_type": "device",
+  "iot_class": "cloud_polling",
+  "quality_scale": "bronze",
+  "requirements": ["airpatrol==0.1.0"]
+}
@@ -0,0 +1,65 @@
+rules:
+  # Bronze
+  action-setup: done
+  appropriate-polling: done
+  brands: done
+  common-modules: done
+  config-flow-test-coverage: done
+  config-flow: done
+  dependency-transparency: done
+  docs-actions:
+    status: exempt
+    comment: Integration does not provide custom actions
+  docs-high-level-description: done
+  docs-installation-instructions: done
+  docs-removal-instructions: done
+  entity-event-setup:
+    status: exempt
+    comment: |
+      Entities doesn't subscribe to events.
+  entity-unique-id: done
+  has-entity-name: done
+  runtime-data: done
+  test-before-configure: done
+  test-before-setup: done
+  unique-config-entry: done
+
+  # Silver
+  action-exceptions: done
+  config-entry-unloading: done
+  docs-configuration-parameters: done
+  docs-installation-parameters: done
+  entity-unavailable: done
+  integration-owner: done
+  log-when-unavailable: todo
+  parallel-updates: done
+  reauthentication-flow: done
+  test-coverage: done
+
+  # Gold
+  devices: done
+  diagnostics: todo
+  discovery-update-info: todo
+  discovery: todo
+  docs-data-update: todo
+  docs-examples: todo
+  docs-known-limitations: todo
+  docs-supported-devices: todo
+  docs-supported-functions: todo
+  docs-troubleshooting: todo
+  docs-use-cases: todo
+  dynamic-devices: todo
+  entity-category: done
+  entity-device-class: done
+  entity-disabled-by-default: todo
+  entity-translations: done
+  exception-translations: todo
+  icon-translations: todo
+  reconfiguration-flow: todo
+  repair-issues: todo
+  stale-devices: todo
+
+  # Platinum
+  async-dependency: todo
+  inject-websession: todo
+  strict-typing: todo
@@ -0,0 +1,38 @@
+{
+  "config": {
+    "abort": {
+      "already_configured": "[%key:common::config_flow::abort::already_configured_device%]",
+      "reauth_successful": "[%key:common::config_flow::abort::reauth_successful%]",
+      "unique_id_mismatch": "Login credentials do not match the configured account"
+    },
+    "error": {
+      "cannot_connect": "[%key:common::config_flow::error::cannot_connect%]",
+      "invalid_auth": "[%key:common::config_flow::error::invalid_auth%]",
+      "unknown": "[%key:common::config_flow::error::unknown%]"
+    },
+    "step": {
+      "reauth_confirm": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "[%key:component::airpatrol::config::step::user::data_description::email%]",
+          "password": "[%key:component::airpatrol::config::step::user::data_description::password%]"
+        },
+        "description": "Reauthenticate with AirPatrol"
+      },
+      "user": {
+        "data": {
+          "email": "[%key:common::config_flow::data::email%]",
+          "password": "[%key:common::config_flow::data::password%]"
+        },
+        "data_description": {
+          "email": "Your AirPatrol email address",
+          "password": "Your AirPatrol password"
+        },
+        "description": "Connect to AirPatrol"
+      }
+    }
+  }
+}
@@ -11,5 +11,5 @@
  "documentation": "https://www.home-assistant.io/integrations/airzone",
  "iot_class": "local_polling",
  "loggers": ["aioairzone"],
-  "requirements": ["aioairzone==1.0.2"]
+  "requirements": ["aioairzone==1.0.4"]
 }
@@ -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"
    }
  }
 }
@@ -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(
@@ -8,5 +8,5 @@
  "iot_class": "cloud_polling",
  "loggers": ["aioamazondevices"],
  "quality_scale": "platinum",
-  "requirements": ["aioamazondevices==9.0.3"]
+  "requirements": ["aioamazondevices==10.0.0"]
 }
@@ -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,9 +34,11 @@ 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],
    )
    try:
        await auth.send_refresh_request()
@@ -45,7 +48,7 @@ async def async_setup_entry(
    _aw = AnglianWater(authenticator=auth)

    try:
-        await _aw.validate_smart_meter()
+        await _aw.validate_smart_meter(entry.data[CONF_ACCOUNT_NUMBER])
    except SmartMeterUnavailableError as err:
        raise ConfigEntryError(
            translation_domain=DOMAIN, translation_key="smart_meter_unavailable"
@@ -7,7 +7,7 @@ from typing import Any

 from aiohttp import CookieJar
 from pyanglianwater import AnglianWater
-from pyanglianwater.auth import BaseAuth, MSOB2CAuth
+from pyanglianwater.auth import MSOB2CAuth
 from pyanglianwater.exceptions import (
    InvalidAccountIdError,
    SelfAssertedError,
@@ -30,11 +30,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
        vol.Required(CONF_PASSWORD): selector.TextSelector(
            selector.TextSelectorConfig(type=selector.TextSelectorType.PASSWORD)
        ),
+        vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
    }
 )


-async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
+async def validate_credentials(
+    auth: MSOB2CAuth, account_number: str
+) -> str | MSOB2CAuth:
    """Validate the provided credentials."""
    try:
        await auth.send_login_request()
@@ -45,7 +48,7 @@ async def validate_credentials(auth: MSOB2CAuth) -> str | MSOB2CAuth:
        return "unknown"
    _aw = AnglianWater(authenticator=auth)
    try:
-        await _aw.validate_smart_meter()
+        await _aw.validate_smart_meter(account_number)
    except (InvalidAccountIdError, SmartMeterUnavailableError):
        return "smart_meter_unavailable"
    return auth
@@ -68,35 +71,21 @@ class AnglianWaterConfigFlow(ConfigFlow, domain=DOMAIN):
                        self.hass,
                        cookie_jar=CookieJar(quote_cookie=False),
                    ),
-                    account_number=user_input.get(CONF_ACCOUNT_NUMBER),
-                )
+                ),
+                user_input[CONF_ACCOUNT_NUMBER],
            )
-            if isinstance(validation_response, BaseAuth):
-                account_number = (
-                    user_input.get(CONF_ACCOUNT_NUMBER)
-                    or validation_response.account_number
-                )
-                await self.async_set_unique_id(account_number)
+            if isinstance(validation_response, str):
+                errors["base"] = validation_response
+            else:
+                await self.async_set_unique_id(user_input[CONF_ACCOUNT_NUMBER])
                self._abort_if_unique_id_configured()
                return self.async_create_entry(
-                    title=account_number,
+                    title=user_input[CONF_ACCOUNT_NUMBER],
                    data={
                        **user_input,
                        CONF_ACCESS_TOKEN: validation_response.refresh_token,
-                        CONF_ACCOUNT_NUMBER: account_number,
                    },
                )
-            if validation_response == "smart_meter_unavailable":
-                return self.async_show_form(
-                    step_id="user",
-                    data_schema=STEP_USER_DATA_SCHEMA.extend(
-                        {
-                            vol.Required(CONF_ACCOUNT_NUMBER): selector.TextSelector(),
-                        }
-                    ),
-                    errors={"base": validation_response},
-                )
-            errors["base"] = validation_response

        return self.async_show_form(
            step_id="user", data_schema=STEP_USER_DATA_SCHEMA, errors=errors
@@ -12,7 +12,7 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed

-from .const import DOMAIN
+from .const import CONF_ACCOUNT_NUMBER, DOMAIN

 type AnglianWaterConfigEntry = ConfigEntry[AnglianWaterUpdateCoordinator]

@@ -44,6 +44,6 @@ class AnglianWaterUpdateCoordinator(DataUpdateCoordinator[None]):
    async def _async_update_data(self) -> None:
        """Update data from Anglian Water's API."""
        try:
-            return await self.api.update()
+            return await self.api.update(self.config_entry.data[CONF_ACCOUNT_NUMBER])
        except (ExpiredAccessTokenError, UnknownEndpointError) as err:
            raise UpdateFailed from err
@@ -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,
        )
@@ -5,6 +5,7 @@
  "config_flow": true,
  "documentation": "https://www.home-assistant.io/integrations/anglian_water",
  "iot_class": "cloud_polling",
+  "loggers": ["pyanglianwater"],
  "quality_scale": "bronze",
-  "requirements": ["pyanglianwater==2.1.0"]
+  "requirements": ["pyanglianwater==3.0.0"]
 }
@@ -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:
@@ -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."
      }
@@ -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
@@ -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,
@@ -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,
        )

@@ -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"]
 }
@@ -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'"],
@@ -3,8 +3,9 @@
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 import logging
+import math

-from pymicro_vad import MicroVad
+from pysilero_vad import SileroVoiceActivityDetector
 from pyspeex_noise import AudioProcessor

 from .const import BYTES_PER_CHUNK
@@ -42,8 +43,8 @@ class AudioEnhancer(ABC):
        """Enhance chunk of PCM audio @ 16Khz with 16-bit mono samples."""


-class MicroVadSpeexEnhancer(AudioEnhancer):
-    """Audio enhancer that runs microVAD and speex."""
+class SileroVadSpeexEnhancer(AudioEnhancer):
+    """Audio enhancer that runs Silero VAD and speex."""

    def __init__(
        self, auto_gain: int, noise_suppression: int, is_vad_enabled: bool
@@ -69,21 +70,49 @@ class MicroVadSpeexEnhancer(AudioEnhancer):
                self.noise_suppression,
            )

-        self.vad: MicroVad | None = None
+        self.vad: SileroVoiceActivityDetector | None = None
+
+        # We get 10ms chunks but Silero works on 32ms chunks, so we have to
+        # buffer audio. The previous speech probability is used until enough
+        # audio has been buffered.
+        self._vad_buffer: bytearray | None = None
+        self._vad_buffer_chunks = 0
+        self._vad_buffer_chunk_idx = 0
+        self._last_speech_probability: float | None = None

        if self.is_vad_enabled:
-            self.vad = MicroVad()
-            _LOGGER.debug("Initialized microVAD")
+            self.vad = SileroVoiceActivityDetector()
+
+            # VAD buffer is a multiple of 10ms, but Silero VAD needs 32ms.
+            self._vad_buffer_chunks = int(
+                math.ceil(self.vad.chunk_bytes() / BYTES_PER_CHUNK)
+            )
+            self._vad_leftover_bytes = self.vad.chunk_bytes() - BYTES_PER_CHUNK
+            self._vad_buffer = bytearray(self.vad.chunk_bytes())
+            _LOGGER.debug("Initialized Silero VAD")

    def enhance_chunk(self, audio: bytes, timestamp_ms: int) -> EnhancedAudioChunk:
        """Enhance 10ms chunk of PCM audio @ 16Khz with 16-bit mono samples."""
-        speech_probability: float | None = None
-
        assert len(audio) == BYTES_PER_CHUNK

        if self.vad is not None:
            # Run VAD
-            speech_probability = self.vad.Process10ms(audio)
+            assert self._vad_buffer is not None
+            start_idx = self._vad_buffer_chunk_idx * BYTES_PER_CHUNK
+            self._vad_buffer[start_idx : start_idx + BYTES_PER_CHUNK] = audio
+
+            self._vad_buffer_chunk_idx += 1
+            if self._vad_buffer_chunk_idx >= self._vad_buffer_chunks:
+                # We have enough data to run Silero VAD (32 ms)
+                self._last_speech_probability = self.vad.process_chunk(
+                    self._vad_buffer[: self.vad.chunk_bytes()]
+                )
+
+                # Copy leftover audio that wasn't processed to start
+                self._vad_buffer[: self._vad_leftover_bytes] = self._vad_buffer[
+                    -self._vad_leftover_bytes :
+                ]
+                self._vad_buffer_chunk_idx = 0

        if self.audio_processor is not None:
            # Run noise suppression and auto gain
@@ -92,5 +121,5 @@ class MicroVadSpeexEnhancer(AudioEnhancer):
        return EnhancedAudioChunk(
            audio=audio,
            timestamp_ms=timestamp_ms,
-            speech_probability=speech_probability,
+            speech_probability=self._last_speech_probability,
        )
@@ -8,5 +8,5 @@
  "integration_type": "system",
  "iot_class": "local_push",
  "quality_scale": "internal",
-  "requirements": ["pymicro-vad==1.0.1", "pyspeex-noise==1.0.2"]
+  "requirements": ["pysilero-vad==3.0.1", "pyspeex-noise==1.0.2"]
 }
@@ -55,7 +55,7 @@ from homeassistant.util import (
 from homeassistant.util.hass_dict import HassKey
 from homeassistant.util.limited_size_dict import LimitedSizeDict

-from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, MicroVadSpeexEnhancer
+from .audio_enhancer import AudioEnhancer, EnhancedAudioChunk, SileroVadSpeexEnhancer
 from .const import (
    ACKNOWLEDGE_PATH,
    BYTES_PER_CHUNK,
@@ -633,7 +633,7 @@ class PipelineRun:
        # Initialize with audio settings
        if self.audio_settings.needs_processor and (self.audio_enhancer is None):
            # Default audio enhancer
-            self.audio_enhancer = MicroVadSpeexEnhancer(
+            self.audio_enhancer = SileroVadSpeexEnhancer(
                self.audio_settings.auto_gain_dbfs,
                self.audio_settings.noise_suppression_level,
                self.audio_settings.is_vad_enabled,
@@ -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(
@@ -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"]
 }
@@ -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"
    }
  }
 }
@@ -7,5 +7,5 @@
  "integration_type": "hub",
  "iot_class": "local_polling",
  "loggers": ["aioasuswrt", "asusrouter", "asyncssh"],
-  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.0"]
+  "requirements": ["aioasuswrt==1.5.1", "asusrouter==1.21.3"]
 }
@@ -29,5 +29,5 @@
  "documentation": "https://www.home-assistant.io/integrations/august",
  "iot_class": "cloud_push",
  "loggers": ["pubnub", "yalexs"],
-  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.1"]
+  "requirements": ["yalexs==9.2.0", "yalexs-ble==3.2.2"]
 }
@@ -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
@@ -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"
    }
  },
@@ -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": {
@@ -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()
@@ -47,7 +47,7 @@ _exception_map = {
 }


-class BangOlufsenConfigFlowHandler(ConfigFlow, domain=DOMAIN):
+class BeoConfigFlowHandler(ConfigFlow, domain=DOMAIN):
    """Handle a config flow."""

    _beolink_jid = ""
@@ -14,21 +14,25 @@ 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,
    "idle": MediaPlayerState.IDLE,
    "paused": MediaPlayerState.PAUSED,
-    "stopped": MediaPlayerState.PAUSED,
+    "stopped": MediaPlayerState.IDLE,
    "ended": MediaPlayerState.PAUSED,
    "error": MediaPlayerState.IDLE,
    # A device's initial state is "unknown" and should be treated as "idle"
@@ -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]] = [
@@ -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."""

@@ -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
@@ -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,
@@ -6,6 +6,6 @@
  "documentation": "https://www.home-assistant.io/integrations/bang_olufsen",
  "integration_type": "device",
  "iot_class": "local_push",
-  "requirements": ["mozart-api==5.1.0.247.1"],
+  "requirements": ["mozart-api==5.3.1.108.0"],
  "zeroconf": ["_bangolufsen._tcp.local."]
 }
@@ -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

@@ -574,7 +583,7 @@ class BangOlufsenMediaPlayer(BangOlufsenEntity, MediaPlayerEntity):
        for sound_mode in sound_modes:
            label = f"{sound_mode.name} ({sound_mode.id})"

-            self._sound_modes[label] = sound_mode.id
+            self._sound_modes[label] = cast(int, sound_mode.id)

            if sound_mode.id == active_sound_mode.id:
                self._attr_sound_mode = label
@@ -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]:
@@ -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,27 @@ 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."""
+    # Beoconnect Core does not have any buttons
+    if model == BeoModel.BEOCONNECT_CORE:
+        return []
+
    buttons = DEVICE_BUTTONS.copy()

-    # Beosound Premiere does not have a bluetooth button
-    if model == BangOlufsenModel.BEOSOUND_PREMIERE:
-        buttons.remove(BangOlufsenButtons.BLUETOOTH)
+    # Models that don't have a microphone button
+    if model in (
+        BeoModel.BEOSOUND_A5,
+        BeoModel.BEOSOUND_A9,
+        BeoModel.BEOSOUND_PREMIERE,
+    ):
+        buttons.remove(BeoButtons.MICROPHONE)

-    # Beoconnect Core does not have any buttons
-    elif model == BangOlufsenModel.BEOCONNECT_CORE:
-        buttons = []
+    # Models that don't have a Bluetooth button
+    if model in (
+        BeoModel.BEOSOUND_A9,
+        BeoModel.BEOSOUND_PREMIERE,
+    ):
+        buttons.remove(BeoButtons.BLUETOOTH)

    return buttons
@@ -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)
@@ -174,5 +174,13 @@
        "on": "mdi:window-open"
      }
    }
+  },
+  "triggers": {
+    "occupancy_cleared": {
+      "trigger": "mdi:home-outline"
+    },
+    "occupancy_detected": {
+      "trigger": "mdi:home"
+    }
  }
 }
@@ -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"
+    }
+  }
 }
@@ -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
@@ -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
@@ -20,5 +20,5 @@
  "documentation": "https://www.home-assistant.io/integrations/blink",
  "iot_class": "cloud_polling",
  "loggers": ["blinkpy"],
-  "requirements": ["blinkpy==0.24.1"]
+  "requirements": ["blinkpy==0.25.1"]
 }
@@ -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"
  ]
 }
@@ -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)
@@ -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):
@@ -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,
@@ -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",
        )

@@ -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"]
 }
@@ -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"]
@@ -2,7 +2,7 @@

 from __future__ import annotations

-from typing import Any
+from typing import Any, Final

 from bsblan import BSBLANError

@@ -17,7 +17,7 @@ from homeassistant.components.climate import (
 )
 from homeassistant.const import ATTR_TEMPERATURE
 from homeassistant.core import HomeAssistant
-from homeassistant.exceptions import HomeAssistantError, ServiceValidationError
+from homeassistant.exceptions import HomeAssistantError
 from homeassistant.helpers.device_registry import format_mac
 from homeassistant.helpers.entity_platform import AddConfigEntryEntitiesCallback
 from homeassistant.util.enum import try_parse_enum
@@ -39,6 +39,22 @@ PRESET_MODES = [
    PRESET_NONE,
 ]

+# Mapping from Home Assistant HVACMode to BSB-Lan integer values
+# BSB-Lan uses: 0=off, 1=auto, 2=eco/reduced, 3=heat/comfort
+HA_TO_BSBLAN_HVAC_MODE: Final[dict[HVACMode, int]] = {
+    HVACMode.OFF: 0,
+    HVACMode.AUTO: 1,
+    HVACMode.HEAT: 3,
+}
+
+# Mapping from BSB-Lan integer values to Home Assistant HVACMode
+BSBLAN_TO_HA_HVAC_MODE: Final[dict[int, HVACMode]] = {
+    0: HVACMode.OFF,
+    1: HVACMode.AUTO,
+    2: HVACMode.AUTO,  # eco/reduced maps to AUTO with preset
+    3: HVACMode.HEAT,
+}
+

 async def async_setup_entry(
    hass: HomeAssistant,
@@ -98,17 +114,20 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):
    @property
    def hvac_mode(self) -> HVACMode | None:
        """Return hvac operation ie. heat, cool mode."""
-        if self.coordinator.data.state.hvac_mode.value == PRESET_ECO:
-            return HVACMode.AUTO
-        return try_parse_enum(HVACMode, self.coordinator.data.state.hvac_mode.value)
+        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
+        if hvac_mode_value is None:
+            return None
+        # BSB-Lan returns integer values: 0=off, 1=auto, 2=eco, 3=heat
+        if isinstance(hvac_mode_value, int):
+            return BSBLAN_TO_HA_HVAC_MODE.get(hvac_mode_value)
+        return try_parse_enum(HVACMode, hvac_mode_value)

    @property
    def preset_mode(self) -> str | None:
        """Return the current preset mode."""
-        if (
-            self.hvac_mode == HVACMode.AUTO
-            and self.coordinator.data.state.hvac_mode.value == PRESET_ECO
-        ):
+        hvac_mode_value = self.coordinator.data.state.hvac_mode.value
+        # BSB-Lan mode 2 is eco/reduced mode
+        if hvac_mode_value == 2:
            return PRESET_ECO
        return PRESET_NONE

@@ -118,13 +137,6 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):

    async def async_set_preset_mode(self, preset_mode: str) -> None:
        """Set preset mode."""
-        if self.hvac_mode != HVACMode.AUTO and preset_mode != PRESET_NONE:
-            raise ServiceValidationError(
-                "Preset mode can only be set when HVAC mode is set to 'auto'",
-                translation_domain=DOMAIN,
-                translation_key="set_preset_mode_error",
-                translation_placeholders={"preset_mode": preset_mode},
-            )
        await self.async_set_data(preset_mode=preset_mode)

    async def async_set_temperature(self, **kwargs: Any) -> None:
@@ -133,16 +145,17 @@ class BSBLANClimate(BSBLanEntity, ClimateEntity):

    async def async_set_data(self, **kwargs: Any) -> None:
        """Set device settings using BSBLAN."""
-        data = {}
+        data: dict[str, Any] = {}
        if ATTR_TEMPERATURE in kwargs:
            data[ATTR_TARGET_TEMPERATURE] = kwargs[ATTR_TEMPERATURE]
        if ATTR_HVAC_MODE in kwargs:
-            data[ATTR_HVAC_MODE] = kwargs[ATTR_HVAC_MODE]
+            data[ATTR_HVAC_MODE] = HA_TO_BSBLAN_HVAC_MODE[kwargs[ATTR_HVAC_MODE]]
        if ATTR_PRESET_MODE in kwargs:
+            # eco preset uses BSB-Lan mode 2, none preset uses mode 1 (auto)
            if kwargs[ATTR_PRESET_MODE] == PRESET_ECO:
-                data[ATTR_HVAC_MODE] = PRESET_ECO
+                data[ATTR_HVAC_MODE] = 2
            elif kwargs[ATTR_PRESET_MODE] == PRESET_NONE:
-                data[ATTR_HVAC_MODE] = PRESET_NONE
+                data[ATTR_HVAC_MODE] = 1

        try:
            await self.coordinator.client.thermostat(**data)
@@ -7,7 +7,7 @@
  "integration_type": "device",
  "iot_class": "local_polling",
  "loggers": ["bsblan"],
-  "requirements": ["python-bsblan==3.1.1"],
+  "requirements": ["python-bsblan==3.1.3"],
  "zeroconf": [
    {
      "name": "bsb-lan*",
@@ -4,7 +4,7 @@ from __future__ import annotations

 from typing import Any

-from bsblan import BSBLANError
+from bsblan import BSBLANError, SetHotWaterParam

 from homeassistant.components.water_heater import (
    STATE_ECO,
@@ -131,7 +131,9 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
        """Set new target temperature."""
        temperature = kwargs.get(ATTR_TEMPERATURE)
        try:
-            await self.coordinator.client.set_hot_water(nominal_setpoint=temperature)
+            await self.coordinator.client.set_hot_water(
+                SetHotWaterParam(nominal_setpoint=temperature)
+            )
        except BSBLANError as err:
            raise HomeAssistantError(
                translation_domain=DOMAIN,
@@ -144,7 +146,9 @@ class BSBLANWaterHeater(BSBLanDualCoordinatorEntity, WaterHeaterEntity):
        """Set new operation mode."""
        bsblan_mode = OPERATION_MODES_REVERSE.get(operation_mode)
        try:
-            await self.coordinator.client.set_hot_water(operating_mode=bsblan_mode)
+            await self.coordinator.client.set_hot_water(
+                SetHotWaterParam(operating_mode=bsblan_mode)
+            )
        except BSBLANError as err:
            raise HomeAssistantError(
                translation_domain=DOMAIN,
@@ -20,7 +20,7 @@ from aiohttp import hdrs, web
 import attr
 from propcache.api import cached_property, under_cached_property
 import voluptuous as vol
-from webrtc_models import RTCIceCandidateInit, RTCIceServer
+from webrtc_models import RTCIceCandidateInit

 from homeassistant.components import websocket_api
 from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssistantView
@@ -37,6 +37,7 @@ from homeassistant.components.stream import (
    Stream,
    create_stream,
 )
+from homeassistant.components.web_rtc import async_get_ice_servers
 from homeassistant.components.websocket_api import ActiveConnection
 from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import (
@@ -84,7 +85,6 @@ from .prefs import (
    get_dynamic_camera_stream_settings,
 )
 from .webrtc import (
-    DATA_ICE_SERVERS,
    CameraWebRTCProvider,
    WebRTCAnswer,  # noqa: F401
    WebRTCCandidate,  # noqa: F401
@@ -93,7 +93,6 @@ from .webrtc import (
    WebRTCMessage,  # noqa: F401
    WebRTCSendMessage,
    async_get_supported_provider,
-    async_register_ice_servers,
    async_register_webrtc_provider,  # noqa: F401
    async_register_ws,
 )
@@ -400,20 +399,6 @@ async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
        SERVICE_RECORD, CAMERA_SERVICE_RECORD, async_handle_record_service
    )

-    @callback
-    def get_ice_servers() -> list[RTCIceServer]:
-        if hass.config.webrtc.ice_servers:
-            return hass.config.webrtc.ice_servers
-        return [
-            RTCIceServer(
-                urls=[
-                    "stun:stun.home-assistant.io:80",
-                    "stun:stun.home-assistant.io:3478",
-                ]
-            ),
-        ]
-
-    async_register_ice_servers(hass, get_ice_servers)
    return True


@@ -731,11 +716,7 @@ class Camera(Entity, cached_properties=CACHED_PROPERTIES_WITH_ATTR_):
        """Return the WebRTC client configuration and extend it with the registered ice servers."""
        config = self._async_get_webrtc_client_configuration()

-        ice_servers = [
-            server
-            for servers in self.hass.data.get(DATA_ICE_SERVERS, [])
-            for server in servers()
-        ]
+        ice_servers = async_get_ice_servers(self.hass)
        config.configuration.ice_servers.extend(ice_servers)

        return config
@@ -3,7 +3,7 @@
  "name": "Camera",
  "after_dependencies": ["media_player"],
  "codeowners": ["@home-assistant/core"],
-  "dependencies": ["http"],
+  "dependencies": ["http", "web_rtc"],
  "documentation": "https://www.home-assistant.io/integrations/camera",
  "integration_type": "entity",
  "quality_scale": "internal",
@@ -4,7 +4,7 @@ from __future__ import annotations

 from abc import ABC, abstractmethod
 import asyncio
-from collections.abc import Awaitable, Callable, Iterable
+from collections.abc import Awaitable, Callable
 from dataclasses import asdict, dataclass, field
 from functools import cache, partial, wraps
 import logging
@@ -12,12 +12,7 @@ from typing import TYPE_CHECKING, Any

 from mashumaro import MissingField
 import voluptuous as vol
-from webrtc_models import (
-    RTCConfiguration,
-    RTCIceCandidate,
-    RTCIceCandidateInit,
-    RTCIceServer,
-)
+from webrtc_models import RTCConfiguration, RTCIceCandidate, RTCIceCandidateInit

 from homeassistant.components import websocket_api
 from homeassistant.core import HomeAssistant, callback
@@ -38,9 +33,6 @@ _LOGGER = logging.getLogger(__name__)
 DATA_WEBRTC_PROVIDERS: HassKey[set[CameraWebRTCProvider]] = HassKey(
    "camera_webrtc_providers"
 )
-DATA_ICE_SERVERS: HassKey[list[Callable[[], Iterable[RTCIceServer]]]] = HassKey(
-    "camera_webrtc_ice_servers"
-)


 _WEBRTC = "WebRTC"
@@ -367,21 +359,3 @@ async def async_get_supported_provider(
            return provider

    return None
-
-
-@callback
-def async_register_ice_servers(
-    hass: HomeAssistant,
-    get_ice_server_fn: Callable[[], Iterable[RTCIceServer]],
-) -> Callable[[], None]:
-    """Register a ICE server.
-
-    The registering integration is responsible to implement caching if needed.
-    """
-    servers = hass.data.setdefault(DATA_ICE_SERVERS, [])
-
-    def remove() -> None:
-        servers.remove(get_ice_server_fn)
-
-    servers.append(get_ice_server_fn)
-    return remove
@@ -98,6 +98,12 @@
    }
  },
  "triggers": {
+    "started_cooling": {
+      "trigger": "mdi:snowflake"
+    },
+    "started_drying": {
+      "trigger": "mdi:water-percent"
+    },
    "started_heating": {
      "trigger": "mdi:fire"
    },
@@ -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"
    }
  }
 }
@@ -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,
@@ -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
@@ -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
@@ -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:
@@ -19,8 +19,8 @@ from homeassistant.components.alexa import (
    errors as alexa_errors,
    smart_home as alexa_smart_home,
 )
-from homeassistant.components.camera import async_register_ice_servers
 from homeassistant.components.google_assistant import smart_home as ga
+from homeassistant.components.web_rtc import async_register_ice_servers
 from homeassistant.const import __version__ as HA_VERSION
 from homeassistant.core import Context, HassJob, HomeAssistant, callback
 from homeassistant.helpers.aiohttp_client import SERVER_SOFTWARE
@@ -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:
@@ -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."""

@@ -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:
@@ -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],
+    )
@@ -8,11 +8,11 @@
    "google_assistant"
  ],
  "codeowners": ["@home-assistant/cloud"],
-  "dependencies": ["auth", "http", "repairs", "webhook"],
+  "dependencies": ["auth", "http", "repairs", "webhook", "web_rtc"],
  "documentation": "https://www.home-assistant.io/integrations/cloud",
  "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
 }
@@ -1,157 +1,19 @@
 """Module for color_extractor (RGB extraction from images) component."""

-import asyncio
-import io
-import logging
-
-import aiohttp
-from colorthief import ColorThief
-from PIL import UnidentifiedImageError
-import voluptuous as vol
-
-from homeassistant.components.light import (
-    ATTR_RGB_COLOR,
-    DOMAIN as LIGHT_DOMAIN,
-    LIGHT_TURN_ON_SCHEMA,
-)
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import SERVICE_TURN_ON as LIGHT_SERVICE_TURN_ON
-from homeassistant.core import HomeAssistant, ServiceCall
-from homeassistant.helpers import aiohttp_client, config_validation as cv
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers import config_validation as cv
 from homeassistant.helpers.typing import ConfigType

-from .const import ATTR_PATH, ATTR_URL, DOMAIN, SERVICE_TURN_ON
-
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN
+from .services import async_setup_services

 CONFIG_SCHEMA = cv.removed(DOMAIN, raise_if_present=False)

-# Extend the existing light.turn_on service schema
-SERVICE_SCHEMA = vol.All(
-    cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
-    cv.make_entity_service_schema(
-        {
-            **LIGHT_TURN_ON_SCHEMA,
-            vol.Exclusive(ATTR_PATH, "color_extractor"): cv.isfile,
-            vol.Exclusive(ATTR_URL, "color_extractor"): cv.url,
-        }
-    ),
-)
-
-
-def _get_file(file_path):
-    """Get a PIL acceptable input file reference.
-
-    Allows us to mock patch during testing to make BytesIO stream.
-    """
-    return file_path
-
-
-def _get_color(file_handler) -> tuple:
-    """Given an image file, extract the predominant color from it."""
-    color_thief = ColorThief(file_handler)
-
-    # get_color returns a SINGLE RGB value for the given image
-    color = color_thief.get_color(quality=1)
-
-    _LOGGER.debug("Extracted RGB color %s from image", color)
-
-    return color
-

 async def async_setup(hass: HomeAssistant, config: ConfigType) -> bool:
    """Set up the Color extractor component."""
-
-    async def async_handle_service(service_call: ServiceCall) -> None:
-        """Decide which color_extractor method to call based on service."""
-        service_data = dict(service_call.data)
-
-        try:
-            if ATTR_URL in service_data:
-                image_type = "URL"
-                image_reference = service_data.pop(ATTR_URL)
-                color = await async_extract_color_from_url(image_reference)
-
-            elif ATTR_PATH in service_data:
-                image_type = "file path"
-                image_reference = service_data.pop(ATTR_PATH)
-                color = await hass.async_add_executor_job(
-                    extract_color_from_path, image_reference
-                )
-
-        except UnidentifiedImageError as ex:
-            _LOGGER.error(
-                "Bad image from %s '%s' provided, are you sure it's an image? %s",
-                image_type,
-                image_reference,
-                ex,
-            )
-            return
-
-        if color:
-            service_data[ATTR_RGB_COLOR] = color
-
-            await hass.services.async_call(
-                LIGHT_DOMAIN, LIGHT_SERVICE_TURN_ON, service_data, blocking=True
-            )
-
-    hass.services.async_register(
-        DOMAIN,
-        SERVICE_TURN_ON,
-        async_handle_service,
-        schema=SERVICE_SCHEMA,
-    )
-
-    async def async_extract_color_from_url(url):
-        """Handle call for URL based image."""
-        if not hass.config.is_allowed_external_url(url):
-            _LOGGER.error(
-                (
-                    "External URL '%s' is not allowed, please add to"
-                    " 'allowlist_external_urls'"
-                ),
-                url,
-            )
-            return None
-
-        _LOGGER.debug("Getting predominant RGB from image URL '%s'", url)
-
-        # Download the image into a buffer for ColorThief to check against
-        try:
-            session = aiohttp_client.async_get_clientsession(hass)
-
-            async with asyncio.timeout(10):
-                response = await session.get(url)
-
-        except (TimeoutError, aiohttp.ClientError) as err:
-            _LOGGER.error("Failed to get ColorThief image due to HTTPError: %s", err)
-            return None
-
-        content = await response.content.read()
-
-        with io.BytesIO(content) as _file:
-            _file.name = "color_extractor.jpg"
-            _file.seek(0)
-
-            return _get_color(_file)
-
-    def extract_color_from_path(file_path):
-        """Handle call for local file based image."""
-        if not hass.config.is_allowed_path(file_path):
-            _LOGGER.error(
-                (
-                    "File path '%s' is not allowed, please add to"
-                    " 'allowlist_external_dirs'"
-                ),
-                file_path,
-            )
-            return None
-
-        _LOGGER.debug("Getting predominant RGB from file path '%s'", file_path)
-
-        _file = _get_file(file_path)
-        return _get_color(_file)
-
+    async_setup_services(hass)
    return True


@@ -0,0 +1,156 @@
+"""Module for color_extractor (RGB extraction from images) component."""
+
+import asyncio
+import io
+import logging
+
+import aiohttp
+from colorthief import ColorThief
+from PIL import UnidentifiedImageError
+import voluptuous as vol
+
+from homeassistant.components.light import (
+    ATTR_RGB_COLOR,
+    DOMAIN as LIGHT_DOMAIN,
+    LIGHT_TURN_ON_SCHEMA,
+)
+from homeassistant.const import SERVICE_TURN_ON as LIGHT_SERVICE_TURN_ON
+from homeassistant.core import HomeAssistant, ServiceCall, callback
+from homeassistant.helpers import aiohttp_client, config_validation as cv
+
+from .const import ATTR_PATH, ATTR_URL, DOMAIN, SERVICE_TURN_ON
+
+_LOGGER = logging.getLogger(__name__)
+
+# Extend the existing light.turn_on service schema
+SERVICE_SCHEMA = vol.All(
+    cv.has_at_least_one_key(ATTR_URL, ATTR_PATH),
+    cv.make_entity_service_schema(
+        {
+            **LIGHT_TURN_ON_SCHEMA,
+            vol.Exclusive(ATTR_PATH, "color_extractor"): cv.isfile,
+            vol.Exclusive(ATTR_URL, "color_extractor"): cv.url,
+        }
+    ),
+)
+
+
+def _get_file(file_path: str) -> str:
+    """Get a PIL acceptable input file reference.
+
+    Allows us to mock patch during testing to make BytesIO stream.
+    """
+    return file_path
+
+
+def _get_color(file_handler: io.BytesIO | str) -> tuple[int, int, int]:
+    """Given an image file, extract the predominant color from it."""
+    color_thief = ColorThief(file_handler)
+
+    # get_color returns a SINGLE RGB value for the given image
+    color = color_thief.get_color(quality=1)
+
+    _LOGGER.debug("Extracted RGB color %s from image", color)
+
+    return color
+
+
+async def _async_extract_color_from_url(
+    hass: HomeAssistant, url: str
+) -> tuple[int, int, int] | None:
+    """Handle call for URL based image."""
+    if not hass.config.is_allowed_external_url(url):
+        _LOGGER.error(
+            (
+                "External URL '%s' is not allowed, please add to"
+                " 'allowlist_external_urls'"
+            ),
+            url,
+        )
+        return None
+
+    _LOGGER.debug("Getting predominant RGB from image URL '%s'", url)
+
+    # Download the image into a buffer for ColorThief to check against
+    try:
+        session = aiohttp_client.async_get_clientsession(hass)
+
+        async with asyncio.timeout(10):
+            response = await session.get(url)
+
+    except (TimeoutError, aiohttp.ClientError) as err:
+        _LOGGER.error("Failed to get ColorThief image due to HTTPError: %s", err)
+        return None
+
+    content = await response.content.read()
+
+    with io.BytesIO(content) as _file:
+        _file.name = "color_extractor.jpg"
+        _file.seek(0)
+
+        return _get_color(_file)
+
+
+def _extract_color_from_path(
+    hass: HomeAssistant, file_path: str
+) -> tuple[int, int, int] | None:
+    """Handle call for local file based image."""
+    if not hass.config.is_allowed_path(file_path):
+        _LOGGER.error(
+            "File path '%s' is not allowed, please add to 'allowlist_external_dirs'",
+            file_path,
+        )
+        return None
+
+    _LOGGER.debug("Getting predominant RGB from file path '%s'", file_path)
+
+    _file = _get_file(file_path)
+    return _get_color(_file)
+
+
+async def async_handle_service(service_call: ServiceCall) -> None:
+    """Decide which color_extractor method to call based on service."""
+    service_data = dict(service_call.data)
+
+    try:
+        if ATTR_URL in service_data:
+            image_type = "URL"
+            image_reference = service_data.pop(ATTR_URL)
+            color = await _async_extract_color_from_url(
+                service_call.hass, image_reference
+            )
+
+        elif ATTR_PATH in service_data:
+            image_type = "file path"
+            image_reference = service_data.pop(ATTR_PATH)
+            color = await service_call.hass.async_add_executor_job(
+                _extract_color_from_path, service_call.hass, image_reference
+            )
+
+    except UnidentifiedImageError as ex:
+        _LOGGER.error(
+            "Bad image from %s '%s' provided, are you sure it's an image? %s",
+            image_type,
+            image_reference,
+            ex,
+        )
+        return
+
+    if color:
+        service_data[ATTR_RGB_COLOR] = color
+
+        await service_call.hass.services.async_call(
+            LIGHT_DOMAIN, LIGHT_SERVICE_TURN_ON, service_data, blocking=True
+        )
+
+
+@callback
+def async_setup_services(hass: HomeAssistant) -> None:
+    """Register the services."""
+
+    hass.services.async_register(
+        DOMAIN,
+        SERVICE_TURN_ON,
+        async_handle_service,
+        schema=SERVICE_SCHEMA,
+    )
--- a/Show More
+++ b/Show More