preen

This reverts commit 1226e581ec.

CODEOWNERS

@@ -150,7 +150,6 @@ esphome/components/esp32_improv/* @jesserockz
 esphome/components/esp32_rmt/* @jesserockz
 esphome/components/esp32_rmt_led_strip/* @jesserockz
 esphome/components/esp8266/* @esphome/core
-esphome/components/esp_ldo/* @clydebarrow
 esphome/components/ethernet_info/* @gtjadsonsantos
 esphome/components/event/* @nohat
 esphome/components/event_emitter/* @Rapsssito
@@ -322,7 +321,6 @@ esphome/components/number/* @esphome/core
 esphome/components/one_wire/* @ssieb
 esphome/components/online_image/* @clydebarrow @guillempages
 esphome/components/opentherm/* @olegtarasov
-esphome/components/openthread/* @mrene
 esphome/components/ota/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow

Doxyfile

@@ -48,7 +48,7 @@ PROJECT_NAME           = ESPHome
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = 2025.7.0-dev
+PROJECT_NUMBER         = 2025.6.0-dev
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

esphome/__main__.py

@@ -134,7 +134,6 @@ def get_port_type(port):
 
 
 def run_miniterm(config, port, args):
-    from aioesphomeapi import LogParser
     import serial
 
     from esphome import platformio_api
@@ -159,7 +158,6 @@ def run_miniterm(config, port, args):
         ser.dtr = False
         ser.rts = False
 
-    parser = LogParser()
     tries = 0
     while tries < 5:
         try:
@@ -176,7 +174,8 @@ def run_miniterm(config, port, args):
                         .decode("utf8", "backslashreplace")
                     )
                     time_str = datetime.now().time().strftime("[%H:%M:%S]")
-                    safe_print(parser.parse_line(line, time_str))
+                    message = time_str + line
+                    safe_print(message)
 
                     backtrace_state = platformio_api.process_stacktrace(
                         config, line, backtrace_state=backtrace_state

esphome/components/absolute_humidity/absolute_humidity.cpp

@@ -40,11 +40,9 @@ void AbsoluteHumidityComponent::dump_config() {
       break;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "Sources\n"
-                "  Temperature: '%s'\n"
-                "  Relative Humidity: '%s'",
-                this->temperature_sensor_->get_name().c_str(), this->humidity_sensor_->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "Sources");
+  ESP_LOGCONFIG(TAG, "  Temperature: '%s'", this->temperature_sensor_->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "  Relative Humidity: '%s'", this->humidity_sensor_->get_name().c_str());
 }
 
 float AbsoluteHumidityComponent::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/ac_dimmer/ac_dimmer.cpp

@@ -214,10 +214,8 @@ void AcDimmer::dump_config() {
   ESP_LOGCONFIG(TAG, "AcDimmer:");
   LOG_PIN("  Output Pin: ", this->gate_pin_);
   LOG_PIN("  Zero-Cross Pin: ", this->zero_cross_pin_);
-  ESP_LOGCONFIG(TAG,
-                "   Min Power: %.1f%%\n"
-                "   Init with half cycle: %s",
-                this->store_.min_power / 10.0f, YESNO(this->init_with_half_cycle_));
+  ESP_LOGCONFIG(TAG, "   Min Power: %.1f%%", this->store_.min_power / 10.0f);
+  ESP_LOGCONFIG(TAG, "   Init with half cycle: %s", YESNO(this->init_with_half_cycle_));
   if (method_ == DIM_METHOD_LEADING_PULSE) {
     ESP_LOGCONFIG(TAG, "   Method: leading pulse");
   } else if (method_ == DIM_METHOD_LEADING) {

esphome/components/adc/adc_sensor.h

@@ -72,6 +72,10 @@ class ADCSensor : public sensor::Sensor, public PollingComponent, public voltage
   void set_sampling_mode(SamplingMode sampling_mode);
   float sample() override;
 
+#ifdef USE_ESP8266
+  std::string unique_id() override;
+#endif  // USE_ESP8266
+
 #ifdef USE_RP2040
   void set_is_temperature() { this->is_temperature_ = true; }
 #endif  // USE_RP2040

esphome/components/adc/adc_sensor_esp32.cpp

@@ -77,10 +77,8 @@ void ADCSensor::dump_config() {
         break;
     }
   }
-  ESP_LOGCONFIG(TAG,
-                "  Samples: %i\n"
-                "  Sampling mode: %s",
-                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
+  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_esp8266.cpp

@@ -30,10 +30,8 @@ void ADCSensor::dump_config() {
 #else
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG,
-                "  Samples: %i\n"
-                "  Sampling mode: %s",
-                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
+  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 
@@ -56,6 +54,8 @@ float ADCSensor::sample() {
   return aggr.aggregate() / 1024.0f;
 }
 
+std::string ADCSensor::unique_id() { return get_mac_address() + "-adc"; }
+
 }  // namespace adc
 }  // namespace esphome
 

esphome/components/adc/adc_sensor_libretiny.cpp

@@ -22,10 +22,8 @@ void ADCSensor::dump_config() {
 #else   // USE_ADC_SENSOR_VCC
   LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
-  ESP_LOGCONFIG(TAG,
-                "  Samples: %i\n"
-                "  Sampling mode: %s",
-                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
+  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/adc/adc_sensor_rp2040.cpp

@@ -33,10 +33,8 @@ void ADCSensor::dump_config() {
     LOG_PIN("  Pin: ", this->pin_);
 #endif  // USE_ADC_SENSOR_VCC
   }
-  ESP_LOGCONFIG(TAG,
-                "  Samples: %i\n"
-                "  Sampling mode: %s",
-                this->sample_count_, LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
+  ESP_LOGCONFIG(TAG, "  Samples: %i", this->sample_count_);
+  ESP_LOGCONFIG(TAG, "  Sampling mode: %s", LOG_STR_ARG(sampling_mode_to_str(this->sampling_mode_)));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/ade7880/ade7880.cpp

@@ -177,14 +177,11 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_a_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_a_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_a_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG,
-                  "    Calibration:\n"
-                  "     Current: %" PRId32 "\n"
-                  "     Voltage: %" PRId32 "\n"
-                  "     Power: %" PRId32 "\n"
-                  "     Phase Angle: %u",
-                  this->channel_a_->current_gain_calibration, this->channel_a_->voltage_gain_calibration,
-                  this->channel_a_->power_gain_calibration, this->channel_a_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG, "    Calibration:");
+    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_a_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_a_->voltage_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_a_->power_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_a_->phase_angle_calibration);
   }
 
   if (this->channel_b_ != nullptr) {
@@ -196,14 +193,11 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_b_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_b_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_b_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG,
-                  "    Calibration:\n"
-                  "     Current: %" PRId32 "\n"
-                  "     Voltage: %" PRId32 "\n"
-                  "     Power: %" PRId32 "\n"
-                  "     Phase Angle: %u",
-                  this->channel_b_->current_gain_calibration, this->channel_b_->voltage_gain_calibration,
-                  this->channel_b_->power_gain_calibration, this->channel_b_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG, "    Calibration:");
+    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_b_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_b_->voltage_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_b_->power_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_b_->phase_angle_calibration);
   }
 
   if (this->channel_c_ != nullptr) {
@@ -215,23 +209,18 @@ void ADE7880::dump_config() {
     LOG_SENSOR("    ", "Power Factor", this->channel_c_->power_factor);
     LOG_SENSOR("    ", "Forward Active Energy", this->channel_c_->forward_active_energy);
     LOG_SENSOR("    ", "Reverse Active Energy", this->channel_c_->reverse_active_energy);
-    ESP_LOGCONFIG(TAG,
-                  "    Calibration:\n"
-                  "     Current: %" PRId32 "\n"
-                  "     Voltage: %" PRId32 "\n"
-                  "     Power: %" PRId32 "\n"
-                  "     Phase Angle: %u",
-                  this->channel_c_->current_gain_calibration, this->channel_c_->voltage_gain_calibration,
-                  this->channel_c_->power_gain_calibration, this->channel_c_->phase_angle_calibration);
+    ESP_LOGCONFIG(TAG, "    Calibration:");
+    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_c_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Voltage: %" PRId32, this->channel_c_->voltage_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Power: %" PRId32, this->channel_c_->power_gain_calibration);
+    ESP_LOGCONFIG(TAG, "     Phase Angle: %u", this->channel_c_->phase_angle_calibration);
   }
 
   if (this->channel_n_ != nullptr) {
     ESP_LOGCONFIG(TAG, "  Neutral:");
     LOG_SENSOR("    ", "Current", this->channel_n_->current);
-    ESP_LOGCONFIG(TAG,
-                  "    Calibration:\n"
-                  "     Current: %" PRId32,
-                  this->channel_n_->current_gain_calibration);
+    ESP_LOGCONFIG(TAG, "    Calibration:");
+    ESP_LOGCONFIG(TAG, "     Current: %" PRId32, this->channel_n_->current_gain_calibration);
   }
 
   LOG_I2C_DEVICE(this);

esphome/components/ade7953_base/ade7953_base.cpp

@@ -58,18 +58,15 @@ void ADE7953::dump_config() {
   LOG_SENSOR("  ", "Active Power B Sensor", this->active_power_b_sensor_);
   LOG_SENSOR("  ", "Rective Power A Sensor", this->reactive_power_a_sensor_);
   LOG_SENSOR("  ", "Reactive Power B Sensor", this->reactive_power_b_sensor_);
-  ESP_LOGCONFIG(TAG,
-                "  USE_ACC_ENERGY_REGS: %d\n"
-                "  PGA_V_8: 0x%X\n"
-                "  PGA_IA_8: 0x%X\n"
-                "  PGA_IB_8: 0x%X\n"
-                "  VGAIN_32: 0x%08jX\n"
-                "  AIGAIN_32: 0x%08jX\n"
-                "  BIGAIN_32: 0x%08jX\n"
-                "  AWGAIN_32: 0x%08jX\n"
-                "  BWGAIN_32: 0x%08jX",
-                this->use_acc_energy_regs_, pga_v_, pga_ia_, pga_ib_, (uintmax_t) vgain_, (uintmax_t) aigain_,
-                (uintmax_t) bigain_, (uintmax_t) awgain_, (uintmax_t) bwgain_);
+  ESP_LOGCONFIG(TAG, "  USE_ACC_ENERGY_REGS: %d", this->use_acc_energy_regs_);
+  ESP_LOGCONFIG(TAG, "  PGA_V_8: 0x%X", pga_v_);
+  ESP_LOGCONFIG(TAG, "  PGA_IA_8: 0x%X", pga_ia_);
+  ESP_LOGCONFIG(TAG, "  PGA_IB_8: 0x%X", pga_ib_);
+  ESP_LOGCONFIG(TAG, "  VGAIN_32: 0x%08jX", (uintmax_t) vgain_);
+  ESP_LOGCONFIG(TAG, "  AIGAIN_32: 0x%08jX", (uintmax_t) aigain_);
+  ESP_LOGCONFIG(TAG, "  BIGAIN_32: 0x%08jX", (uintmax_t) bigain_);
+  ESP_LOGCONFIG(TAG, "  AWGAIN_32: 0x%08jX", (uintmax_t) awgain_);
+  ESP_LOGCONFIG(TAG, "  BWGAIN_32: 0x%08jX", (uintmax_t) bwgain_);
 }
 
 #define ADE_PUBLISH_(name, val, factor) \

esphome/components/ade7953_i2c/ade7953_i2c.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_i2c.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace ade7953_i2c {

esphome/components/ade7953_spi/ade7953_spi.cpp

@@ -1,6 +1,6 @@
 #include "ade7953_spi.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace ade7953_spi {

esphome/components/ads1118/ads1118.cpp

@@ -1,5 +1,4 @@
 #include "ads1118.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/ags10/ags10.cpp

@@ -1,5 +1,4 @@
 #include "ags10.h"
-#include "esphome/core/helpers.h"
 
 #include <cinttypes>
 

esphome/components/aht10/aht10.cpp

@@ -13,9 +13,9 @@
 // results making successive requests; the current implementation makes 3 attempts with a delay of 30ms each time.
 
 #include "aht10.h"
+#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 
 namespace esphome {
 namespace aht10 {

esphome/components/alarm_control_panel/__init__.py

@@ -235,7 +235,6 @@ async def register_alarm_control_panel(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_alarm_control_panel(var))
-    CORE.register_platform_component("alarm_control_panel", var)
     await setup_alarm_control_panel_core_(var, config)
 
 

esphome/components/am43/am43_base.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace am43 {

esphome/components/am43/cover/am43_cover.cpp

@@ -12,10 +12,8 @@ using namespace esphome::cover;
 
 void Am43Component::dump_config() {
   LOG_COVER("", "AM43 Cover", this);
-  ESP_LOGCONFIG(TAG,
-                "  Device Pin: %d\n"
-                "  Invert Position: %d",
-                this->pin_, (int) this->invert_position_);
+  ESP_LOGCONFIG(TAG, "  Device Pin: %d", this->pin_);
+  ESP_LOGCONFIG(TAG, "  Invert Position: %d", (int) this->invert_position_);
 }
 
 void Am43Component::setup() {

esphome/components/analog_threshold/analog_threshold_binary_sensor.cpp

@@ -34,10 +34,8 @@ void AnalogThresholdBinarySensor::set_sensor(sensor::Sensor *analog_sensor) {
 void AnalogThresholdBinarySensor::dump_config() {
   LOG_BINARY_SENSOR("", "Analog Threshold Binary Sensor", this);
   LOG_SENSOR("  ", "Sensor", this->sensor_);
-  ESP_LOGCONFIG(TAG,
-                "  Upper threshold: %.11f\n"
-                "  Lower threshold: %.11f",
-                this->upper_threshold_.value(), this->lower_threshold_.value());
+  ESP_LOGCONFIG(TAG, "  Upper threshold: %.11f", this->upper_threshold_.value());
+  ESP_LOGCONFIG(TAG, "  Lower threshold: %.11f", this->lower_threshold_.value());
 }
 
 }  // namespace analog_threshold

esphome/components/apds9306/apds9306.cpp

@@ -108,12 +108,9 @@ void APDS9306::dump_config() {
     }
   }
 
-  ESP_LOGCONFIG(TAG,
-                "  Gain: %u\n"
-                "  Measurement rate: %u\n"
-                "  Measurement Resolution/Bit width: %d",
-                AMBIENT_LIGHT_GAIN_VALUES[this->gain_], MEASUREMENT_RATE_VALUES[this->measurement_rate_],
-                MEASUREMENT_BIT_WIDTH_VALUES[this->bit_width_]);
+  ESP_LOGCONFIG(TAG, "  Gain: %u", AMBIENT_LIGHT_GAIN_VALUES[this->gain_]);
+  ESP_LOGCONFIG(TAG, "  Measurement rate: %u", MEASUREMENT_RATE_VALUES[this->measurement_rate_]);
+  ESP_LOGCONFIG(TAG, "  Measurement Resolution/Bit width: %d", MEASUREMENT_BIT_WIDTH_VALUES[this->bit_width_]);
 
   LOG_UPDATE_INTERVAL(this);
 }

esphome/components/api/api.proto

@@ -272,6 +272,7 @@ message ListEntitiesBinarySensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string device_class = 5;
   bool is_status_binary_sensor = 6;
@@ -301,6 +302,7 @@ message ListEntitiesCoverResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   bool assumed_state = 5;
   bool supports_position = 6;
@@ -371,6 +373,7 @@ message ListEntitiesFanResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   bool supports_oscillation = 5;
   bool supports_speed = 6;
@@ -447,6 +450,7 @@ message ListEntitiesLightResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   repeated ColorMode supported_color_modes = 12;
   // next four supports_* are for legacy clients, newer clients should use color modes
@@ -538,6 +542,7 @@ message ListEntitiesSensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   string unit_of_measurement = 6;
@@ -572,6 +577,7 @@ message ListEntitiesSwitchResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool assumed_state = 6;
@@ -607,6 +613,7 @@ message ListEntitiesTextSensorResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -788,6 +795,7 @@ message ListEntitiesCameraResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
   bool disabled_by_default = 5;
   string icon = 6;
   EntityCategory entity_category = 7;
@@ -867,6 +875,7 @@ message ListEntitiesClimateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   bool supports_current_temperature = 5;
   bool supports_two_point_target_temperature = 6;
@@ -961,6 +970,7 @@ message ListEntitiesNumberResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   float min_value = 6;
@@ -1003,6 +1013,7 @@ message ListEntitiesSelectResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   repeated string options = 6;
@@ -1040,6 +1051,7 @@ message ListEntitiesSirenResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1096,6 +1108,7 @@ message ListEntitiesLockResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1138,6 +1151,7 @@ message ListEntitiesButtonResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1188,6 +1202,7 @@ message ListEntitiesMediaPlayerResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1726,6 +1741,7 @@ message ListEntitiesAlarmControlPanelResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
   string icon = 5;
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
@@ -1766,6 +1782,7 @@ message ListEntitiesTextResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
   string icon = 5;
   bool disabled_by_default = 6;
   EntityCategory entity_category = 7;
@@ -1807,6 +1824,7 @@ message ListEntitiesDateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1847,6 +1865,7 @@ message ListEntitiesTimeResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1887,6 +1906,7 @@ message ListEntitiesEventResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1913,6 +1933,7 @@ message ListEntitiesValveResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1961,6 +1982,7 @@ message ListEntitiesDateTimeResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;
@@ -1997,6 +2019,7 @@ message ListEntitiesUpdateResponse {
   string object_id = 1;
   fixed32 key = 2;
   string name = 3;
+  string unique_id = 4;
 
   string icon = 5;
   bool disabled_by_default = 6;

esphome/components/api/api_connection.cpp

@@ -225,6 +225,10 @@ void APIConnection::loop() {
   }
 }
 
+std::string get_default_unique_id(const std::string &component_type, EntityBase *entity) {
+  return App.get_name() + component_type + entity->get_object_id();
+}
+
 DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
   // remote initiated disconnect_client
   // don't close yet, we still need to send the disconnect response
@@ -235,8 +239,7 @@ DisconnectResponse APIConnection::disconnect(const DisconnectRequest &msg) {
   return resp;
 }
 void APIConnection::on_disconnect_response(const DisconnectResponse &value) {
-  this->helper_->close();
-  this->remove_ = true;
+  // pass
 }
 
 // Encodes a message to the buffer and returns the total number of bytes used,
@@ -266,6 +269,10 @@ uint16_t APIConnection::encode_message_to_buffer(ProtoMessage &msg, uint16_t mes
 }
 
 #ifdef USE_BINARY_SENSOR
+bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state) {
+  return this->schedule_message_(binary_sensor, MessageCreator(state, BinarySensorStateResponse::MESSAGE_TYPE),
+                                 BinarySensorStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor) {
   return this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_state,
                                  BinarySensorStateResponse::MESSAGE_TYPE);
@@ -274,15 +281,20 @@ void APIConnection::send_binary_sensor_info(binary_sensor::BinarySensor *binary_
   this->schedule_message_(binary_sensor, &APIConnection::try_send_binary_sensor_info,
                           ListEntitiesBinarySensorResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_binary_sensor_state_response(binary_sensor::BinarySensor *binary_sensor, bool state,
+                                                              APIConnection *conn, uint32_t remaining_size,
+                                                              bool is_single) {
+  BinarySensorStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !binary_sensor->has_state();
+  resp.key = binary_sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, BinarySensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                      bool is_single) {
   auto *binary_sensor = static_cast<binary_sensor::BinarySensor *>(entity);
-  BinarySensorStateResponse resp;
-  resp.state = binary_sensor->state;
-  resp.missing_state = !binary_sensor->has_state();
-  resp.key = binary_sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, BinarySensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_binary_sensor_state_response(binary_sensor, binary_sensor->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -291,6 +303,7 @@ uint16_t APIConnection::try_send_binary_sensor_info(EntityBase *entity, APIConne
   ListEntitiesBinarySensorResponse msg;
   msg.device_class = binary_sensor->get_device_class();
   msg.is_status_binary_sensor = binary_sensor->is_status_binary_sensor();
+  msg.unique_id = get_default_unique_id("binary_sensor", binary_sensor);
   fill_entity_info_base(binary_sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesBinarySensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -327,6 +340,7 @@ uint16_t APIConnection::try_send_cover_info(EntityBase *entity, APIConnection *c
   msg.supports_tilt = traits.get_supports_tilt();
   msg.supports_stop = traits.get_supports_stop();
   msg.device_class = cover->get_device_class();
+  msg.unique_id = get_default_unique_id("cover", cover);
   fill_entity_info_base(cover, msg);
   return encode_message_to_buffer(msg, ListEntitiesCoverResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -395,6 +409,7 @@ uint16_t APIConnection::try_send_fan_info(EntityBase *entity, APIConnection *con
   msg.supported_speed_count = traits.supported_speed_count();
   for (auto const &preset : traits.supported_preset_modes())
     msg.supported_preset_modes.push_back(preset);
+  msg.unique_id = get_default_unique_id("fan", fan);
   fill_entity_info_base(fan, msg);
   return encode_message_to_buffer(msg, ListEntitiesFanResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -474,6 +489,7 @@ uint16_t APIConnection::try_send_light_info(EntityBase *entity, APIConnection *c
       msg.effects.push_back(effect->get_name());
     }
   }
+  msg.unique_id = get_default_unique_id("light", light);
   fill_entity_info_base(light, msg);
   return encode_message_to_buffer(msg, ListEntitiesLightResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -515,21 +531,29 @@ void APIConnection::light_command(const LightCommandRequest &msg) {
 #endif
 
 #ifdef USE_SENSOR
+bool APIConnection::send_sensor_state(sensor::Sensor *sensor, float state) {
+  return this->schedule_message_(sensor, MessageCreator(state, SensorStateResponse::MESSAGE_TYPE),
+                                 SensorStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_sensor_state(sensor::Sensor *sensor) {
   return this->schedule_message_(sensor, &APIConnection::try_send_sensor_state, SensorStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_sensor_info(sensor::Sensor *sensor) {
   this->schedule_message_(sensor, &APIConnection::try_send_sensor_info, ListEntitiesSensorResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_sensor_state_response(sensor::Sensor *sensor, float state, APIConnection *conn,
+                                                       uint32_t remaining_size, bool is_single) {
+  SensorStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !sensor->has_state();
+  resp.key = sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *sensor = static_cast<sensor::Sensor *>(entity);
-  SensorStateResponse resp;
-  resp.state = sensor->state;
-  resp.missing_state = !sensor->has_state();
-  resp.key = sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, SensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_sensor_state_response(sensor, sensor->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -541,26 +565,37 @@ uint16_t APIConnection::try_send_sensor_info(EntityBase *entity, APIConnection *
   msg.force_update = sensor->get_force_update();
   msg.device_class = sensor->get_device_class();
   msg.state_class = static_cast<enums::SensorStateClass>(sensor->get_state_class());
+  msg.unique_id = sensor->unique_id();
+  if (msg.unique_id.empty())
+    msg.unique_id = get_default_unique_id("sensor", sensor);
   fill_entity_info_base(sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 #endif
 
 #ifdef USE_SWITCH
+bool APIConnection::send_switch_state(switch_::Switch *a_switch, bool state) {
+  return this->schedule_message_(a_switch, MessageCreator(state, SwitchStateResponse::MESSAGE_TYPE),
+                                 SwitchStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_switch_state(switch_::Switch *a_switch) {
   return this->schedule_message_(a_switch, &APIConnection::try_send_switch_state, SwitchStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_switch_info(switch_::Switch *a_switch) {
   this->schedule_message_(a_switch, &APIConnection::try_send_switch_info, ListEntitiesSwitchResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_switch_state_response(switch_::Switch *a_switch, bool state, APIConnection *conn,
+                                                       uint32_t remaining_size, bool is_single) {
+  SwitchStateResponse resp;
+  resp.state = state;
+  resp.key = a_switch->get_object_id_hash();
+  return encode_message_to_buffer(resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *a_switch = static_cast<switch_::Switch *>(entity);
-  SwitchStateResponse resp;
-  resp.state = a_switch->state;
-  resp.key = a_switch->get_object_id_hash();
-  return encode_message_to_buffer(resp, SwitchStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_switch_state_response(a_switch, a_switch->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -569,6 +604,7 @@ uint16_t APIConnection::try_send_switch_info(EntityBase *entity, APIConnection *
   ListEntitiesSwitchResponse msg;
   msg.assumed_state = a_switch->assumed_state();
   msg.device_class = a_switch->get_device_class();
+  msg.unique_id = get_default_unique_id("switch", a_switch);
   fill_entity_info_base(a_switch, msg);
   return encode_message_to_buffer(msg, ListEntitiesSwitchResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -586,6 +622,10 @@ void APIConnection::switch_command(const SwitchCommandRequest &msg) {
 #endif
 
 #ifdef USE_TEXT_SENSOR
+bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor, const std::string &state) {
+  return this->schedule_message_(text_sensor, MessageCreator(state, TextSensorStateResponse::MESSAGE_TYPE),
+                                 TextSensorStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_text_sensor_state(text_sensor::TextSensor *text_sensor) {
   return this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_state,
                                  TextSensorStateResponse::MESSAGE_TYPE);
@@ -594,21 +634,29 @@ void APIConnection::send_text_sensor_info(text_sensor::TextSensor *text_sensor)
   this->schedule_message_(text_sensor, &APIConnection::try_send_text_sensor_info,
                           ListEntitiesTextSensorResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_text_sensor_state_response(text_sensor::TextSensor *text_sensor,
+                                                            const std::string &state, APIConnection *conn,
+                                                            uint32_t remaining_size, bool is_single) {
+  TextSensorStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !text_sensor->has_state();
+  resp.key = text_sensor->get_object_id_hash();
+  return encode_message_to_buffer(resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                    bool is_single) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
-  TextSensorStateResponse resp;
-  resp.state = text_sensor->state;
-  resp.missing_state = !text_sensor->has_state();
-  resp.key = text_sensor->get_object_id_hash();
-  return encode_message_to_buffer(resp, TextSensorStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_text_sensor_state_response(text_sensor, text_sensor->get_state(), conn, remaining_size, is_single);
 }
 uint16_t APIConnection::try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                                   bool is_single) {
   auto *text_sensor = static_cast<text_sensor::TextSensor *>(entity);
   ListEntitiesTextSensorResponse msg;
   msg.device_class = text_sensor->get_device_class();
+  msg.unique_id = text_sensor->unique_id();
+  if (msg.unique_id.empty())
+    msg.unique_id = get_default_unique_id("text_sensor", text_sensor);
   fill_entity_info_base(text_sensor, msg);
   return encode_message_to_buffer(msg, ListEntitiesTextSensorResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -683,6 +731,7 @@ uint16_t APIConnection::try_send_climate_info(EntityBase *entity, APIConnection
     msg.supported_custom_presets.push_back(custom_preset);
   for (auto swing_mode : traits.get_supported_swing_modes())
     msg.supported_swing_modes.push_back(static_cast<enums::ClimateSwingMode>(swing_mode));
+  msg.unique_id = get_default_unique_id("climate", climate);
   fill_entity_info_base(climate, msg);
   return encode_message_to_buffer(msg, ListEntitiesClimateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -717,21 +766,29 @@ void APIConnection::climate_command(const ClimateCommandRequest &msg) {
 #endif
 
 #ifdef USE_NUMBER
+bool APIConnection::send_number_state(number::Number *number, float state) {
+  return this->schedule_message_(number, MessageCreator(state, NumberStateResponse::MESSAGE_TYPE),
+                                 NumberStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_number_state(number::Number *number) {
   return this->schedule_message_(number, &APIConnection::try_send_number_state, NumberStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_number_info(number::Number *number) {
   this->schedule_message_(number, &APIConnection::try_send_number_info, ListEntitiesNumberResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_number_state_response(number::Number *number, float state, APIConnection *conn,
+                                                       uint32_t remaining_size, bool is_single) {
+  NumberStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !number->has_state();
+  resp.key = number->get_object_id_hash();
+  return encode_message_to_buffer(resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *number = static_cast<number::Number *>(entity);
-  NumberStateResponse resp;
-  resp.state = number->state;
-  resp.missing_state = !number->has_state();
-  resp.key = number->get_object_id_hash();
-  return encode_message_to_buffer(resp, NumberStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_number_state_response(number, number->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -744,6 +801,7 @@ uint16_t APIConnection::try_send_number_info(EntityBase *entity, APIConnection *
   msg.min_value = number->traits.get_min_value();
   msg.max_value = number->traits.get_max_value();
   msg.step = number->traits.get_step();
+  msg.unique_id = get_default_unique_id("number", number);
   fill_entity_info_base(number, msg);
   return encode_message_to_buffer(msg, ListEntitiesNumberResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -780,6 +838,7 @@ uint16_t APIConnection::try_send_date_info(EntityBase *entity, APIConnection *co
                                            bool is_single) {
   auto *date = static_cast<datetime::DateEntity *>(entity);
   ListEntitiesDateResponse msg;
+  msg.unique_id = get_default_unique_id("date", date);
   fill_entity_info_base(date, msg);
   return encode_message_to_buffer(msg, ListEntitiesDateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -816,6 +875,7 @@ uint16_t APIConnection::try_send_time_info(EntityBase *entity, APIConnection *co
                                            bool is_single) {
   auto *time = static_cast<datetime::TimeEntity *>(entity);
   ListEntitiesTimeResponse msg;
+  msg.unique_id = get_default_unique_id("time", time);
   fill_entity_info_base(time, msg);
   return encode_message_to_buffer(msg, ListEntitiesTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -854,6 +914,7 @@ uint16_t APIConnection::try_send_datetime_info(EntityBase *entity, APIConnection
                                                bool is_single) {
   auto *datetime = static_cast<datetime::DateTimeEntity *>(entity);
   ListEntitiesDateTimeResponse msg;
+  msg.unique_id = get_default_unique_id("datetime", datetime);
   fill_entity_info_base(datetime, msg);
   return encode_message_to_buffer(msg, ListEntitiesDateTimeResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -869,21 +930,29 @@ void APIConnection::datetime_command(const DateTimeCommandRequest &msg) {
 #endif
 
 #ifdef USE_TEXT
+bool APIConnection::send_text_state(text::Text *text, const std::string &state) {
+  return this->schedule_message_(text, MessageCreator(state, TextStateResponse::MESSAGE_TYPE),
+                                 TextStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_text_state(text::Text *text) {
   return this->schedule_message_(text, &APIConnection::try_send_text_state, TextStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_text_info(text::Text *text) {
   this->schedule_message_(text, &APIConnection::try_send_text_info, ListEntitiesTextResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_text_state_response(text::Text *text, const std::string &state, APIConnection *conn,
+                                                     uint32_t remaining_size, bool is_single) {
+  TextStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !text->has_state();
+  resp.key = text->get_object_id_hash();
+  return encode_message_to_buffer(resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
   auto *text = static_cast<text::Text *>(entity);
-  TextStateResponse resp;
-  resp.state = text->state;
-  resp.missing_state = !text->has_state();
-  resp.key = text->get_object_id_hash();
-  return encode_message_to_buffer(resp, TextStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_text_state_response(text, text->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -894,6 +963,7 @@ uint16_t APIConnection::try_send_text_info(EntityBase *entity, APIConnection *co
   msg.min_length = text->traits.get_min_length();
   msg.max_length = text->traits.get_max_length();
   msg.pattern = text->traits.get_pattern();
+  msg.unique_id = get_default_unique_id("text", text);
   fill_entity_info_base(text, msg);
   return encode_message_to_buffer(msg, ListEntitiesTextResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -909,21 +979,29 @@ void APIConnection::text_command(const TextCommandRequest &msg) {
 #endif
 
 #ifdef USE_SELECT
+bool APIConnection::send_select_state(select::Select *select, const std::string &state) {
+  return this->schedule_message_(select, MessageCreator(state, SelectStateResponse::MESSAGE_TYPE),
+                                 SelectStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_select_state(select::Select *select) {
   return this->schedule_message_(select, &APIConnection::try_send_select_state, SelectStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_select_info(select::Select *select) {
   this->schedule_message_(select, &APIConnection::try_send_select_info, ListEntitiesSelectResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_select_state_response(select::Select *select, const std::string &state,
+                                                       APIConnection *conn, uint32_t remaining_size, bool is_single) {
+  SelectStateResponse resp;
+  resp.state = state;
+  resp.missing_state = !select->has_state();
+  resp.key = select->get_object_id_hash();
+  return encode_message_to_buffer(resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single) {
   auto *select = static_cast<select::Select *>(entity);
-  SelectStateResponse resp;
-  resp.state = select->state;
-  resp.missing_state = !select->has_state();
-  resp.key = select->get_object_id_hash();
-  return encode_message_to_buffer(resp, SelectStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_select_state_response(select, select->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -932,6 +1010,7 @@ uint16_t APIConnection::try_send_select_info(EntityBase *entity, APIConnection *
   ListEntitiesSelectResponse msg;
   for (const auto &option : select->traits.get_options())
     msg.options.push_back(option);
+  msg.unique_id = get_default_unique_id("select", select);
   fill_entity_info_base(select, msg);
   return encode_message_to_buffer(msg, ListEntitiesSelectResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -955,6 +1034,7 @@ uint16_t APIConnection::try_send_button_info(EntityBase *entity, APIConnection *
   auto *button = static_cast<button::Button *>(entity);
   ListEntitiesButtonResponse msg;
   msg.device_class = button->get_device_class();
+  msg.unique_id = get_default_unique_id("button", button);
   fill_entity_info_base(button, msg);
   return encode_message_to_buffer(msg, ListEntitiesButtonResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -968,20 +1048,28 @@ void esphome::api::APIConnection::button_command(const ButtonCommandRequest &msg
 #endif
 
 #ifdef USE_LOCK
+bool APIConnection::send_lock_state(lock::Lock *a_lock, lock::LockState state) {
+  return this->schedule_message_(a_lock, MessageCreator(state, LockStateResponse::MESSAGE_TYPE),
+                                 LockStateResponse::MESSAGE_TYPE);
+}
 bool APIConnection::send_lock_state(lock::Lock *a_lock) {
   return this->schedule_message_(a_lock, &APIConnection::try_send_lock_state, LockStateResponse::MESSAGE_TYPE);
 }
 void APIConnection::send_lock_info(lock::Lock *a_lock) {
   this->schedule_message_(a_lock, &APIConnection::try_send_lock_info, ListEntitiesLockResponse::MESSAGE_TYPE);
 }
+uint16_t APIConnection::try_send_lock_state_response(lock::Lock *a_lock, lock::LockState state, APIConnection *conn,
+                                                     uint32_t remaining_size, bool is_single) {
+  LockStateResponse resp;
+  resp.state = static_cast<enums::LockState>(state);
+  resp.key = a_lock->get_object_id_hash();
+  return encode_message_to_buffer(resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+}
 
 uint16_t APIConnection::try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                             bool is_single) {
   auto *a_lock = static_cast<lock::Lock *>(entity);
-  LockStateResponse resp;
-  resp.state = static_cast<enums::LockState>(a_lock->state);
-  resp.key = a_lock->get_object_id_hash();
-  return encode_message_to_buffer(resp, LockStateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
+  return try_send_lock_state_response(a_lock, a_lock->state, conn, remaining_size, is_single);
 }
 
 uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -991,6 +1079,7 @@ uint16_t APIConnection::try_send_lock_info(EntityBase *entity, APIConnection *co
   msg.assumed_state = a_lock->traits.get_assumed_state();
   msg.supports_open = a_lock->traits.get_supports_open();
   msg.requires_code = a_lock->traits.get_requires_code();
+  msg.unique_id = get_default_unique_id("lock", a_lock);
   fill_entity_info_base(a_lock, msg);
   return encode_message_to_buffer(msg, ListEntitiesLockResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1038,6 +1127,7 @@ uint16_t APIConnection::try_send_valve_info(EntityBase *entity, APIConnection *c
   msg.assumed_state = traits.get_is_assumed_state();
   msg.supports_position = traits.get_supports_position();
   msg.supports_stop = traits.get_supports_stop();
+  msg.unique_id = get_default_unique_id("valve", valve);
   fill_entity_info_base(valve, msg);
   return encode_message_to_buffer(msg, ListEntitiesValveResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1092,6 +1182,7 @@ uint16_t APIConnection::try_send_media_player_info(EntityBase *entity, APIConnec
     media_format.sample_bytes = supported_format.sample_bytes;
     msg.supported_formats.push_back(media_format);
   }
+  msg.unique_id = get_default_unique_id("media_player", media_player);
   fill_entity_info_base(media_player, msg);
   return encode_message_to_buffer(msg, ListEntitiesMediaPlayerResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1134,6 +1225,7 @@ uint16_t APIConnection::try_send_camera_info(EntityBase *entity, APIConnection *
                                              bool is_single) {
   auto *camera = static_cast<esp32_camera::ESP32Camera *>(entity);
   ListEntitiesCameraResponse msg;
+  msg.unique_id = get_default_unique_id("camera", camera);
   fill_entity_info_base(camera, msg);
   return encode_message_to_buffer(msg, ListEntitiesCameraResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1346,6 +1438,7 @@ uint16_t APIConnection::try_send_alarm_control_panel_info(EntityBase *entity, AP
   msg.supported_features = a_alarm_control_panel->get_supported_features();
   msg.requires_code = a_alarm_control_panel->get_requires_code();
   msg.requires_code_to_arm = a_alarm_control_panel->get_requires_code_to_arm();
+  msg.unique_id = get_default_unique_id("alarm_control_panel", a_alarm_control_panel);
   fill_entity_info_base(a_alarm_control_panel, msg);
   return encode_message_to_buffer(msg, ListEntitiesAlarmControlPanelResponse::MESSAGE_TYPE, conn, remaining_size,
                                   is_single);
@@ -1406,6 +1499,7 @@ uint16_t APIConnection::try_send_event_info(EntityBase *entity, APIConnection *c
   msg.device_class = event->get_device_class();
   for (const auto &event_type : event->get_event_types())
     msg.event_types.push_back(event_type);
+  msg.unique_id = get_default_unique_id("event", event);
   fill_entity_info_base(event, msg);
   return encode_message_to_buffer(msg, ListEntitiesEventResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1443,6 +1537,7 @@ uint16_t APIConnection::try_send_update_info(EntityBase *entity, APIConnection *
   auto *update = static_cast<update::UpdateEntity *>(entity);
   ListEntitiesUpdateResponse msg;
   msg.device_class = update->get_device_class();
+  msg.unique_id = get_default_unique_id("update", update);
   fill_entity_info_base(update, msg);
   return encode_message_to_buffer(msg, ListEntitiesUpdateResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
@@ -1837,6 +1932,63 @@ uint16_t APIConnection::MessageCreator::operator()(EntityBase *entity, APIConnec
     case 0:  // Function pointer
       return data_.ptr(entity, conn, remaining_size, is_single);
 
+#ifdef USE_BINARY_SENSOR
+    case BinarySensorStateResponse::MESSAGE_TYPE: {
+      auto *bs = static_cast<binary_sensor::BinarySensor *>(entity);
+      return APIConnection::try_send_binary_sensor_state_response(bs, data_.bool_value, conn, remaining_size,
+                                                                  is_single);
+    }
+#endif
+
+#ifdef USE_SENSOR
+    case SensorStateResponse::MESSAGE_TYPE: {
+      auto *s = static_cast<sensor::Sensor *>(entity);
+      return APIConnection::try_send_sensor_state_response(s, data_.float_value, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_SWITCH
+    case SwitchStateResponse::MESSAGE_TYPE: {
+      auto *sw = static_cast<switch_::Switch *>(entity);
+      return APIConnection::try_send_switch_state_response(sw, data_.bool_value, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_TEXT_SENSOR
+    case TextSensorStateResponse::MESSAGE_TYPE: {
+      auto *ts = static_cast<text_sensor::TextSensor *>(entity);
+      return APIConnection::try_send_text_sensor_state_response(ts, *data_.string_ptr, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_SELECT
+    case SelectStateResponse::MESSAGE_TYPE: {
+      auto *s = static_cast<select::Select *>(entity);
+      return APIConnection::try_send_select_state_response(s, *data_.string_ptr, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_NUMBER
+    case NumberStateResponse::MESSAGE_TYPE: {
+      auto *n = static_cast<number::Number *>(entity);
+      return APIConnection::try_send_number_state_response(n, data_.float_value, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_TEXT
+    case TextStateResponse::MESSAGE_TYPE: {
+      auto *t = static_cast<text::Text *>(entity);
+      return APIConnection::try_send_text_state_response(t, *data_.string_ptr, conn, remaining_size, is_single);
+    }
+#endif
+
+#ifdef USE_LOCK
+    case LockStateResponse::MESSAGE_TYPE: {
+      auto *l = static_cast<lock::Lock *>(entity);
+      return APIConnection::try_send_lock_state_response(l, data_.lock_value, conn, remaining_size, is_single);
+    }
+#endif
+
 #ifdef USE_EVENT
     case EventResponse::MESSAGE_TYPE: {
       auto *e = static_cast<event::Event *>(entity);
@@ -1856,12 +2008,6 @@ uint16_t APIConnection::try_send_list_info_done(EntityBase *entity, APIConnectio
   return encode_message_to_buffer(resp, ListEntitiesDoneResponse::MESSAGE_TYPE, conn, remaining_size, is_single);
 }
 
-uint16_t APIConnection::try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                                    bool is_single) {
-  DisconnectRequest req;
-  return encode_message_to_buffer(req, DisconnectRequest::MESSAGE_TYPE, conn, remaining_size, is_single);
-}
-
 uint16_t APIConnection::get_estimated_message_size(uint16_t message_type) {
   // Use generated ESTIMATED_SIZE constants from each message type
   switch (message_type) {
@@ -1997,8 +2143,6 @@ uint16_t APIConnection::get_estimated_message_size(uint16_t message_type) {
       return ListEntitiesServicesResponse::ESTIMATED_SIZE;
     case ListEntitiesDoneResponse::MESSAGE_TYPE:
       return ListEntitiesDoneResponse::ESTIMATED_SIZE;
-    case DisconnectRequest::MESSAGE_TYPE:
-      return DisconnectRequest::ESTIMATED_SIZE;
     default:
       // Fallback for unknown message types
       return 24;

esphome/components/api/api_connection.h

@@ -33,6 +33,7 @@ class APIConnection : public APIServerConnection {
                                    ListEntitiesDoneResponse::MESSAGE_TYPE);
   }
 #ifdef USE_BINARY_SENSOR
+  bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor, bool state);
   bool send_binary_sensor_state(binary_sensor::BinarySensor *binary_sensor);
   void send_binary_sensor_info(binary_sensor::BinarySensor *binary_sensor);
 #endif
@@ -52,15 +53,18 @@ class APIConnection : public APIServerConnection {
   void light_command(const LightCommandRequest &msg) override;
 #endif
 #ifdef USE_SENSOR
+  bool send_sensor_state(sensor::Sensor *sensor, float state);
   bool send_sensor_state(sensor::Sensor *sensor);
   void send_sensor_info(sensor::Sensor *sensor);
 #endif
 #ifdef USE_SWITCH
+  bool send_switch_state(switch_::Switch *a_switch, bool state);
   bool send_switch_state(switch_::Switch *a_switch);
   void send_switch_info(switch_::Switch *a_switch);
   void switch_command(const SwitchCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT_SENSOR
+  bool send_text_sensor_state(text_sensor::TextSensor *text_sensor, const std::string &state);
   bool send_text_sensor_state(text_sensor::TextSensor *text_sensor);
   void send_text_sensor_info(text_sensor::TextSensor *text_sensor);
 #endif
@@ -75,6 +79,7 @@ class APIConnection : public APIServerConnection {
   void climate_command(const ClimateCommandRequest &msg) override;
 #endif
 #ifdef USE_NUMBER
+  bool send_number_state(number::Number *number, float state);
   bool send_number_state(number::Number *number);
   void send_number_info(number::Number *number);
   void number_command(const NumberCommandRequest &msg) override;
@@ -95,11 +100,13 @@ class APIConnection : public APIServerConnection {
   void datetime_command(const DateTimeCommandRequest &msg) override;
 #endif
 #ifdef USE_TEXT
+  bool send_text_state(text::Text *text, const std::string &state);
   bool send_text_state(text::Text *text);
   void send_text_info(text::Text *text);
   void text_command(const TextCommandRequest &msg) override;
 #endif
 #ifdef USE_SELECT
+  bool send_select_state(select::Select *select, const std::string &state);
   bool send_select_state(select::Select *select);
   void send_select_info(select::Select *select);
   void select_command(const SelectCommandRequest &msg) override;
@@ -109,6 +116,7 @@ class APIConnection : public APIServerConnection {
   void button_command(const ButtonCommandRequest &msg) override;
 #endif
 #ifdef USE_LOCK
+  bool send_lock_state(lock::Lock *a_lock, lock::LockState state);
   bool send_lock_state(lock::Lock *a_lock);
   void send_lock_info(lock::Lock *a_lock);
   void lock_command(const LockCommandRequest &msg) override;
@@ -308,7 +316,9 @@ class APIConnection : public APIServerConnection {
                                            uint32_t remaining_size, bool is_single);
 
 #ifdef USE_BINARY_SENSOR
-  static uint16_t try_send_binary_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
+  static uint16_t try_send_binary_sensor_state_response(binary_sensor::BinarySensor *binary_sensor, bool state,
+                                                        APIConnection *conn, uint32_t remaining_size, bool is_single);
+  static uint16_t try_send_binary_sensor_state(EntityBase *binary_sensor, APIConnection *conn, uint32_t remaining_size,
                                                bool is_single);
   static uint16_t try_send_binary_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                               bool is_single);
@@ -328,18 +338,24 @@ class APIConnection : public APIServerConnection {
   static uint16_t try_send_light_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SENSOR
+  static uint16_t try_send_sensor_state_response(sensor::Sensor *sensor, float state, APIConnection *conn,
+                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
 #ifdef USE_SWITCH
+  static uint16_t try_send_switch_state_response(switch_::Switch *a_switch, bool state, APIConnection *conn,
+                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_switch_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_switch_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                        bool is_single);
 #endif
 #ifdef USE_TEXT_SENSOR
+  static uint16_t try_send_text_sensor_state_response(text_sensor::TextSensor *text_sensor, const std::string &state,
+                                                      APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_sensor_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                              bool is_single);
   static uint16_t try_send_text_sensor_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -352,6 +368,8 @@ class APIConnection : public APIServerConnection {
                                         bool is_single);
 #endif
 #ifdef USE_NUMBER
+  static uint16_t try_send_number_state_response(number::Number *number, float state, APIConnection *conn,
+                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_number_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_number_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -372,10 +390,14 @@ class APIConnection : public APIServerConnection {
                                          bool is_single);
 #endif
 #ifdef USE_TEXT
+  static uint16_t try_send_text_state_response(text::Text *text, const std::string &state, APIConnection *conn,
+                                               uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_text_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
 #ifdef USE_SELECT
+  static uint16_t try_send_select_state_response(select::Select *select, const std::string &state, APIConnection *conn,
+                                                 uint32_t remaining_size, bool is_single);
   static uint16_t try_send_select_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                         bool is_single);
   static uint16_t try_send_select_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
@@ -386,6 +408,8 @@ class APIConnection : public APIServerConnection {
                                        bool is_single);
 #endif
 #ifdef USE_LOCK
+  static uint16_t try_send_lock_state_response(lock::Lock *a_lock, lock::LockState state, APIConnection *conn,
+                                               uint32_t remaining_size, bool is_single);
   static uint16_t try_send_lock_state(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
   static uint16_t try_send_lock_info(EntityBase *entity, APIConnection *conn, uint32_t remaining_size, bool is_single);
 #endif
@@ -426,10 +450,6 @@ class APIConnection : public APIServerConnection {
   static uint16_t try_send_list_info_done(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
                                           bool is_single);
 
-  // Method for DisconnectRequest batching
-  static uint16_t try_send_disconnect_request(EntityBase *entity, APIConnection *conn, uint32_t remaining_size,
-                                              bool is_single);
-
   // Helper function to get estimated message size for buffer pre-allocation
   static uint16_t get_estimated_message_size(uint16_t message_type);
 
@@ -474,11 +494,22 @@ class APIConnection : public APIServerConnection {
     // Constructor for function pointer (message_type = 0)
     MessageCreator(MessageCreatorPtr ptr) : message_type_(0) { data_.ptr = ptr; }
 
+    // Constructor for bool state capture
+    MessageCreator(bool value, uint16_t msg_type) : message_type_(msg_type) { data_.bool_value = value; }
+
+    // Constructor for float state capture
+    MessageCreator(float value, uint16_t msg_type) : message_type_(msg_type) { data_.float_value = value; }
+
     // Constructor for string state capture
     MessageCreator(const std::string &value, uint16_t msg_type) : message_type_(msg_type) {
       data_.string_ptr = new std::string(value);
     }
 
+#ifdef USE_LOCK
+    // Constructor for lock state capture
+    MessageCreator(lock::LockState value, uint16_t msg_type) : message_type_(msg_type) { data_.lock_value = value; }
+#endif
+
     // Destructor
     ~MessageCreator() {
       // Clean up string data for string-based message types
@@ -545,12 +576,21 @@ class APIConnection : public APIServerConnection {
 
    private:
     // Helper to check if this message type uses heap-allocated strings
-    bool uses_string_data_() const { return message_type_ == EventResponse::MESSAGE_TYPE; }
+    bool uses_string_data_() const {
+      return message_type_ == TextSensorStateResponse::MESSAGE_TYPE ||
+             message_type_ == SelectStateResponse::MESSAGE_TYPE || message_type_ == TextStateResponse::MESSAGE_TYPE ||
+             message_type_ == EventResponse::MESSAGE_TYPE;
+    }
     union CreatorData {
       MessageCreatorPtr ptr;    // 8 bytes
+      bool bool_value;          // 1 byte
+      float float_value;        // 4 bytes
       std::string *string_ptr;  // 8 bytes
-    } data_;                    // 8 bytes
-    uint16_t message_type_;     // 2 bytes (0 = function ptr, >0 = state capture)
+#ifdef USE_LOCK
+      lock::LockState lock_value;  // 4 bytes
+#endif
+    } data_;                 // 8 bytes
+    uint16_t message_type_;  // 2 bytes (0 = function ptr, >0 = state capture)
   };
 
   // Generic batching mechanism for both state updates and entity info

esphome/components/api/api_frame_helper.cpp

@@ -1,9 +1,9 @@
 #include "api_frame_helper.h"
 #ifdef USE_API
-#include "esphome/core/application.h"
+#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
+#include "esphome/core/application.h"
 #include "proto.h"
 #include "api_pb2_size.h"
 #include <cstring>

esphome/components/api/api_pb2.cpp

@@ -1079,6 +1079,10 @@ bool ListEntitiesBinarySensorResponse::decode_length(uint32_t field_id, ProtoLen
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->device_class = value.as_string();
       return true;
@@ -1105,6 +1109,7 @@ void ListEntitiesBinarySensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->device_class);
   buffer.encode_bool(6, this->is_status_binary_sensor);
   buffer.encode_bool(7, this->disabled_by_default);
@@ -1115,6 +1120,7 @@ void ListEntitiesBinarySensorResponse::calculate_size(uint32_t &total_size) cons
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->device_class, false);
   ProtoSize::add_bool_field(total_size, 1, this->is_status_binary_sensor, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
@@ -1138,6 +1144,10 @@ void ListEntitiesBinarySensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  device_class: ");
   out.append("'").append(this->device_class).append("'");
   out.append("\n");
@@ -1253,6 +1263,10 @@ bool ListEntitiesCoverResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 8: {
       this->device_class = value.as_string();
       return true;
@@ -1279,6 +1293,7 @@ void ListEntitiesCoverResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->assumed_state);
   buffer.encode_bool(6, this->supports_position);
   buffer.encode_bool(7, this->supports_tilt);
@@ -1292,6 +1307,7 @@ void ListEntitiesCoverResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_position, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_tilt, false);
@@ -1318,6 +1334,10 @@ void ListEntitiesCoverResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  assumed_state: ");
   out.append(YESNO(this->assumed_state));
   out.append("\n");
@@ -1572,6 +1592,10 @@ bool ListEntitiesFanResponse::decode_length(uint32_t field_id, ProtoLengthDelimi
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 10: {
       this->icon = value.as_string();
       return true;
@@ -1598,6 +1622,7 @@ void ListEntitiesFanResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->supports_oscillation);
   buffer.encode_bool(6, this->supports_speed);
   buffer.encode_bool(7, this->supports_direction);
@@ -1613,6 +1638,7 @@ void ListEntitiesFanResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_oscillation, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_speed, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_direction, false);
@@ -1643,6 +1669,10 @@ void ListEntitiesFanResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  supports_oscillation: ");
   out.append(YESNO(this->supports_oscillation));
   out.append("\n");
@@ -1984,6 +2014,10 @@ bool ListEntitiesLightResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 11: {
       this->effects.push_back(value.as_string());
       return true;
@@ -2018,6 +2052,7 @@ void ListEntitiesLightResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   for (auto &it : this->supported_color_modes) {
     buffer.encode_enum<enums::ColorMode>(12, it, true);
   }
@@ -2038,6 +2073,7 @@ void ListEntitiesLightResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   if (!this->supported_color_modes.empty()) {
     for (const auto &it : this->supported_color_modes) {
       ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(it), true);
@@ -2075,6 +2111,10 @@ void ListEntitiesLightResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   for (const auto &it : this->supported_color_modes) {
     out.append("  supported_color_modes: ");
     out.append(proto_enum_to_string<enums::ColorMode>(it));
@@ -2645,6 +2685,10 @@ bool ListEntitiesSensorResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -2675,6 +2719,7 @@ void ListEntitiesSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_string(6, this->unit_of_measurement);
   buffer.encode_int32(7, this->accuracy_decimals);
@@ -2689,6 +2734,7 @@ void ListEntitiesSensorResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_string_field(total_size, 1, this->unit_of_measurement, false);
   ProtoSize::add_int32_field(total_size, 1, this->accuracy_decimals, false);
@@ -2716,6 +2762,10 @@ void ListEntitiesSensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -2837,6 +2887,10 @@ bool ListEntitiesSwitchResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -2863,6 +2917,7 @@ void ListEntitiesSwitchResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->assumed_state);
   buffer.encode_bool(7, this->disabled_by_default);
@@ -2873,6 +2928,7 @@ void ListEntitiesSwitchResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->assumed_state, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
@@ -2896,6 +2952,10 @@ void ListEntitiesSwitchResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -3028,6 +3088,10 @@ bool ListEntitiesTextSensorResponse::decode_length(uint32_t field_id, ProtoLengt
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -3054,6 +3118,7 @@ void ListEntitiesTextSensorResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -3063,6 +3128,7 @@ void ListEntitiesTextSensorResponse::calculate_size(uint32_t &total_size) const
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -3085,6 +3151,10 @@ void ListEntitiesTextSensorResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -3885,6 +3955,10 @@ bool ListEntitiesCameraResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 6: {
       this->icon = value.as_string();
       return true;
@@ -3907,6 +3981,7 @@ void ListEntitiesCameraResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->disabled_by_default);
   buffer.encode_string(6, this->icon);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -3915,6 +3990,7 @@ void ListEntitiesCameraResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -3936,6 +4012,10 @@ void ListEntitiesCameraResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  disabled_by_default: ");
   out.append(YESNO(this->disabled_by_default));
   out.append("\n");
@@ -4109,6 +4189,10 @@ bool ListEntitiesClimateResponse::decode_length(uint32_t field_id, ProtoLengthDe
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 15: {
       this->supported_custom_fan_modes.push_back(value.as_string());
       return true;
@@ -4163,6 +4247,7 @@ void ListEntitiesClimateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_bool(5, this->supports_current_temperature);
   buffer.encode_bool(6, this->supports_two_point_target_temperature);
   for (auto &it : this->supported_modes) {
@@ -4201,6 +4286,7 @@ void ListEntitiesClimateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_current_temperature, false);
   ProtoSize::add_bool_field(total_size, 1, this->supports_two_point_target_temperature, false);
   if (!this->supported_modes.empty()) {
@@ -4264,6 +4350,10 @@ void ListEntitiesClimateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  supports_current_temperature: ");
   out.append(YESNO(this->supports_current_temperature));
   out.append("\n");
@@ -4844,6 +4934,10 @@ bool ListEntitiesNumberResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -4886,6 +4980,7 @@ void ListEntitiesNumberResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_float(6, this->min_value);
   buffer.encode_float(7, this->max_value);
@@ -4900,6 +4995,7 @@ void ListEntitiesNumberResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->min_value != 0.0f, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->max_value != 0.0f, false);
@@ -4927,6 +5023,10 @@ void ListEntitiesNumberResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5084,6 +5184,10 @@ bool ListEntitiesSelectResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5110,6 +5214,7 @@ void ListEntitiesSelectResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   for (auto &it : this->options) {
     buffer.encode_string(6, it, true);
@@ -5121,6 +5226,7 @@ void ListEntitiesSelectResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   if (!this->options.empty()) {
     for (const auto &it : this->options) {
@@ -5147,6 +5253,10 @@ void ListEntitiesSelectResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5301,6 +5411,10 @@ bool ListEntitiesSirenResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5327,6 +5441,7 @@ void ListEntitiesSirenResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   for (auto &it : this->tones) {
@@ -5340,6 +5455,7 @@ void ListEntitiesSirenResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   if (!this->tones.empty()) {
@@ -5368,6 +5484,10 @@ void ListEntitiesSirenResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5596,6 +5716,10 @@ bool ListEntitiesLockResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5622,6 +5746,7 @@ void ListEntitiesLockResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -5634,6 +5759,7 @@ void ListEntitiesLockResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -5659,6 +5785,10 @@ void ListEntitiesLockResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -5825,6 +5955,10 @@ bool ListEntitiesButtonResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -5851,6 +5985,7 @@ void ListEntitiesButtonResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -5860,6 +5995,7 @@ void ListEntitiesButtonResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -5882,6 +6018,10 @@ void ListEntitiesButtonResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -6028,6 +6168,10 @@ bool ListEntitiesMediaPlayerResponse::decode_length(uint32_t field_id, ProtoLeng
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -6054,6 +6198,7 @@ void ListEntitiesMediaPlayerResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -6066,6 +6211,7 @@ void ListEntitiesMediaPlayerResponse::calculate_size(uint32_t &total_size) const
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -6089,6 +6235,10 @@ void ListEntitiesMediaPlayerResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -8440,6 +8590,10 @@ bool ListEntitiesAlarmControlPanelResponse::decode_length(uint32_t field_id, Pro
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -8462,6 +8616,7 @@ void ListEntitiesAlarmControlPanelResponse::encode(ProtoWriteBuffer buffer) cons
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -8473,6 +8628,7 @@ void ListEntitiesAlarmControlPanelResponse::calculate_size(uint32_t &total_size)
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -8497,6 +8653,10 @@ void ListEntitiesAlarmControlPanelResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -8662,6 +8822,10 @@ bool ListEntitiesTextResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -8688,6 +8852,7 @@ void ListEntitiesTextResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -8700,6 +8865,7 @@ void ListEntitiesTextResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -8725,6 +8891,10 @@ void ListEntitiesTextResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -8883,6 +9053,10 @@ bool ListEntitiesDateResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -8905,6 +9079,7 @@ void ListEntitiesDateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -8913,6 +9088,7 @@ void ListEntitiesDateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -8934,6 +9110,10 @@ void ListEntitiesDateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9114,6 +9294,10 @@ bool ListEntitiesTimeResponse::decode_length(uint32_t field_id, ProtoLengthDelim
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9136,6 +9320,7 @@ void ListEntitiesTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9144,6 +9329,7 @@ void ListEntitiesTimeResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9165,6 +9351,10 @@ void ListEntitiesTimeResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9345,6 +9535,10 @@ bool ListEntitiesEventResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9375,6 +9569,7 @@ void ListEntitiesEventResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9387,6 +9582,7 @@ void ListEntitiesEventResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9414,6 +9610,10 @@ void ListEntitiesEventResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9517,6 +9717,10 @@ bool ListEntitiesValveResponse::decode_length(uint32_t field_id, ProtoLengthDeli
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9543,6 +9747,7 @@ void ListEntitiesValveResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9555,6 +9760,7 @@ void ListEntitiesValveResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9580,6 +9786,10 @@ void ListEntitiesValveResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9752,6 +9962,10 @@ bool ListEntitiesDateTimeResponse::decode_length(uint32_t field_id, ProtoLengthD
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9774,6 +9988,7 @@ void ListEntitiesDateTimeResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9782,6 +9997,7 @@ void ListEntitiesDateTimeResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9803,6 +10019,10 @@ void ListEntitiesDateTimeResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");
@@ -9933,6 +10153,10 @@ bool ListEntitiesUpdateResponse::decode_length(uint32_t field_id, ProtoLengthDel
       this->name = value.as_string();
       return true;
     }
+    case 4: {
+      this->unique_id = value.as_string();
+      return true;
+    }
     case 5: {
       this->icon = value.as_string();
       return true;
@@ -9959,6 +10183,7 @@ void ListEntitiesUpdateResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_string(1, this->object_id);
   buffer.encode_fixed32(2, this->key);
   buffer.encode_string(3, this->name);
+  buffer.encode_string(4, this->unique_id);
   buffer.encode_string(5, this->icon);
   buffer.encode_bool(6, this->disabled_by_default);
   buffer.encode_enum<enums::EntityCategory>(7, this->entity_category);
@@ -9968,6 +10193,7 @@ void ListEntitiesUpdateResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->object_id, false);
   ProtoSize::add_fixed_field<4>(total_size, 1, this->key != 0, false);
   ProtoSize::add_string_field(total_size, 1, this->name, false);
+  ProtoSize::add_string_field(total_size, 1, this->unique_id, false);
   ProtoSize::add_string_field(total_size, 1, this->icon, false);
   ProtoSize::add_bool_field(total_size, 1, this->disabled_by_default, false);
   ProtoSize::add_enum_field(total_size, 1, static_cast<uint32_t>(this->entity_category), false);
@@ -9990,6 +10216,10 @@ void ListEntitiesUpdateResponse::dump_to(std::string &out) const {
   out.append("'").append(this->name).append("'");
   out.append("\n");
 
+  out.append("  unique_id: ");
+  out.append("'").append(this->unique_id).append("'");
+  out.append("\n");
+
   out.append("  icon: ");
   out.append("'").append(this->icon).append("'");
   out.append("\n");

esphome/components/api/api_pb2.h

@@ -494,6 +494,7 @@ class ListEntitiesBinarySensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string device_class{};
   bool is_status_binary_sensor{false};
   bool disabled_by_default{false};
@@ -540,6 +541,7 @@ class ListEntitiesCoverResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   bool assumed_state{false};
   bool supports_position{false};
   bool supports_tilt{false};
@@ -616,6 +618,7 @@ class ListEntitiesFanResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   bool supports_oscillation{false};
   bool supports_speed{false};
   bool supports_direction{false};
@@ -701,6 +704,7 @@ class ListEntitiesLightResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::vector<enums::ColorMode> supported_color_modes{};
   bool legacy_supports_brightness{false};
   bool legacy_supports_rgb{false};
@@ -809,6 +813,7 @@ class ListEntitiesSensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   std::string unit_of_measurement{};
   int32_t accuracy_decimals{0};
@@ -859,6 +864,7 @@ class ListEntitiesSwitchResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool assumed_state{false};
   bool disabled_by_default{false};
@@ -923,6 +929,7 @@ class ListEntitiesTextSensorResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1252,6 +1259,7 @@ class ListEntitiesCameraResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   bool disabled_by_default{false};
   std::string icon{};
   enums::EntityCategory entity_category{};
@@ -1315,6 +1323,7 @@ class ListEntitiesClimateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   bool supports_current_temperature{false};
   bool supports_two_point_target_temperature{false};
   std::vector<enums::ClimateMode> supported_modes{};
@@ -1431,6 +1440,7 @@ class ListEntitiesNumberResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   float min_value{0.0f};
   float max_value{0.0f};
@@ -1499,6 +1509,7 @@ class ListEntitiesSelectResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   std::vector<std::string> options{};
   bool disabled_by_default{false};
@@ -1564,6 +1575,7 @@ class ListEntitiesSirenResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   std::vector<std::string> tones{};
@@ -1637,6 +1649,7 @@ class ListEntitiesLockResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1706,6 +1719,7 @@ class ListEntitiesButtonResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -1765,6 +1779,7 @@ class ListEntitiesMediaPlayerResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2648,6 +2663,7 @@ class ListEntitiesAlarmControlPanelResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2715,6 +2731,7 @@ class ListEntitiesTextResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2783,6 +2800,7 @@ class ListEntitiesDateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2850,6 +2868,7 @@ class ListEntitiesTimeResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2917,6 +2936,7 @@ class ListEntitiesEventResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -2962,6 +2982,7 @@ class ListEntitiesValveResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -3031,6 +3052,7 @@ class ListEntitiesDateTimeResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};
@@ -3093,6 +3115,7 @@ class ListEntitiesUpdateResponse : public ProtoMessage {
   std::string object_id{};
   uint32_t key{0};
   std::string name{};
+  std::string unique_id{};
   std::string icon{};
   bool disabled_by_default{false};
   enums::EntityCategory entity_category{};

esphome/components/api/api_server.cpp

@@ -92,12 +92,6 @@ void APIServer::setup() {
 #ifdef USE_LOGGER
   if (logger::global_logger != nullptr) {
     logger::global_logger->add_on_log_callback([this](int level, const char *tag, const char *message) {
-      if (this->shutting_down_) {
-        // Don't try to send logs during shutdown
-        // as it could result in a recursion and
-        // we would be filling a buffer we are trying to clear
-        return;
-      }
       for (auto &c : this->clients_) {
         if (!c->remove_)
           c->try_send_log_message(level, tag, message);
@@ -122,8 +116,8 @@ void APIServer::setup() {
 }
 
 void APIServer::loop() {
-  // Accept new clients only if the socket exists and has incoming connections
-  if (this->socket_ && this->socket_->ready()) {
+  // Accept new clients only if the socket has incoming connections
+  if (this->socket_->ready()) {
     while (true) {
       struct sockaddr_storage source_addr;
       socklen_t addr_len = sizeof(source_addr);
@@ -179,10 +173,8 @@ void APIServer::loop() {
 }
 
 void APIServer::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "API Server:\n"
-                "  Address: %s:%u",
-                network::get_use_address().c_str(), this->port_);
+  ESP_LOGCONFIG(TAG, "API Server:");
+  ESP_LOGCONFIG(TAG, "  Address: %s:%u", network::get_use_address().c_str(), this->port_);
 #ifdef USE_API_NOISE
   ESP_LOGCONFIG(TAG, "  Using noise encryption: %s", YESNO(this->noise_ctx_->has_psk()));
   if (!this->noise_ctx_->has_psk()) {
@@ -230,8 +222,9 @@ void APIServer::handle_disconnect(APIConnection *conn) {}
 void APIServer::on_binary_sensor_update(binary_sensor::BinarySensor *obj, bool state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_binary_sensor_state(obj);
+    use_current ? c->send_binary_sensor_state(obj) : c->send_binary_sensor_state(obj, state);
 }
 #endif
 
@@ -266,8 +259,9 @@ void APIServer::on_light_update(light::LightState *obj) {
 void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_sensor_state(obj);
+    use_current ? c->send_sensor_state(obj) : c->send_sensor_state(obj, state);
 }
 #endif
 
@@ -275,8 +269,9 @@ void APIServer::on_sensor_update(sensor::Sensor *obj, float state) {
 void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_switch_state(obj);
+    use_current ? c->send_switch_state(obj) : c->send_switch_state(obj, state);
 }
 #endif
 
@@ -284,8 +279,9 @@ void APIServer::on_switch_update(switch_::Switch *obj, bool state) {
 void APIServer::on_text_sensor_update(text_sensor::TextSensor *obj, const std::string &state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_text_sensor_state(obj);
+    use_current ? c->send_text_sensor_state(obj) : c->send_text_sensor_state(obj, state);
 }
 #endif
 
@@ -302,8 +298,9 @@ void APIServer::on_climate_update(climate::Climate *obj) {
 void APIServer::on_number_update(number::Number *obj, float state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_number_state(obj);
+    use_current ? c->send_number_state(obj) : c->send_number_state(obj, state);
 }
 #endif
 
@@ -338,8 +335,9 @@ void APIServer::on_datetime_update(datetime::DateTimeEntity *obj) {
 void APIServer::on_text_update(text::Text *obj, const std::string &state) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_text_state(obj);
+    use_current ? c->send_text_state(obj) : c->send_text_state(obj, state);
 }
 #endif
 
@@ -347,8 +345,9 @@ void APIServer::on_text_update(text::Text *obj, const std::string &state) {
 void APIServer::on_select_update(select::Select *obj, const std::string &state, size_t index) {
   if (obj->is_internal())
     return;
+  bool use_current = (state == obj->state);
   for (auto &c : this->clients_)
-    c->send_select_state(obj);
+    use_current ? c->send_select_state(obj) : c->send_select_state(obj, state);
 }
 #endif
 
@@ -488,36 +487,10 @@ void APIServer::request_time() {
 bool APIServer::is_connected() const { return !this->clients_.empty(); }
 
 void APIServer::on_shutdown() {
-  this->shutting_down_ = true;
-
-  // Close the listening socket to prevent new connections
-  if (this->socket_) {
-    this->socket_->close();
-    this->socket_ = nullptr;
-  }
-
-  // Change batch delay to 5ms for quick flushing during shutdown
-  this->batch_delay_ = 5;
-
-  // Send disconnect requests to all connected clients
   for (auto &c : this->clients_) {
-    if (!c->send_message(DisconnectRequest())) {
-      // If we can't send the disconnect request directly (tx_buffer full),
-      // schedule it in the batch so it will be sent with the 5ms timer
-      c->schedule_message_(nullptr, &APIConnection::try_send_disconnect_request, DisconnectRequest::MESSAGE_TYPE);
-    }
+    c->send_message(DisconnectRequest());
   }
-}
-
-bool APIServer::teardown() {
-  // If network is disconnected, no point trying to flush buffers
-  if (!network::is_connected()) {
-    return true;
-  }
-  this->loop();
-
-  // Return true only when all clients have been torn down
-  return this->clients_.empty();
+  delay(10);
 }
 
 }  // namespace api

esphome/components/api/api_server.h

@@ -34,7 +34,6 @@ class APIServer : public Component, public Controller {
   void loop() override;
   void dump_config() override;
   void on_shutdown() override;
-  bool teardown() override;
   bool check_password(const std::string &password) const;
   bool uses_password() const;
   void set_port(uint16_t port);
@@ -142,7 +141,6 @@ class APIServer : public Component, public Controller {
   }
 
  protected:
-  bool shutting_down_ = false;
   std::unique_ptr<socket::Socket> socket_ = nullptr;
   uint16_t port_{6053};
   uint32_t reboot_timeout_{300000};

esphome/components/api/client.py

@@ -5,7 +5,7 @@ from datetime import datetime
 import logging
 from typing import TYPE_CHECKING, Any
 
-from aioesphomeapi import APIClient, parse_log_message
+from aioesphomeapi import APIClient
 from aioesphomeapi.log_runner import async_run
 
 from esphome.const import CONF_KEY, CONF_PASSWORD, CONF_PORT, __version__
@@ -48,10 +48,7 @@ async def async_run_logs(config: dict[str, Any], address: str) -> None:
         text = message.decode("utf8", "backslashreplace")
         if dashboard:
             text = text.replace("\033", "\\033")
-        for parsed_msg in parse_log_message(
-            text, f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]"
-        ):
-            print(parsed_msg)
+        print(f"[{time_.hour:02}:{time_.minute:02}:{time_.second:02}]{text}")
 
     stop = await async_run(cli, on_log, name=name)
     try:

esphome/components/api/homeassistant_service.h

@@ -3,8 +3,8 @@
 #include "api_server.h"
 #ifdef USE_API
 #include "api_pb2.h"
-#include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/automation.h"
 #include <vector>
 
 namespace esphome {

esphome/components/api/proto.cpp

@@ -1,6 +1,5 @@
 #include "proto.h"
 #include <cinttypes>
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 namespace esphome {

esphome/components/api/proto.h

@@ -1,8 +1,8 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 #include <vector>
 

esphome/components/as5600/as5600.cpp

@@ -95,13 +95,11 @@ void AS5600Component::dump_config() {
     return;
   }
 
-  ESP_LOGCONFIG(TAG,
-                "  Watchdog: %d\n"
-                "  Fast Filter: %d\n"
-                "  Slow Filter: %d\n"
-                "  Hysteresis: %d\n"
-                "  Start Position: %d",
-                this->watchdog_, this->fast_filter_, this->slow_filter_, this->hysteresis_, this->start_position_);
+  ESP_LOGCONFIG(TAG, "  Watchdog: %d", this->watchdog_);
+  ESP_LOGCONFIG(TAG, "  Fast Filter: %d", this->fast_filter_);
+  ESP_LOGCONFIG(TAG, "  Slow Filter: %d", this->slow_filter_);
+  ESP_LOGCONFIG(TAG, "  Hysteresis: %d", this->hysteresis_);
+  ESP_LOGCONFIG(TAG, "  Start Position: %d", this->start_position_);
   if (this->end_mode_ == END_MODE_POSITION) {
     ESP_LOGCONFIG(TAG, "  End Position: %d", this->end_position_);
   } else {

esphome/components/as7341/as7341.cpp

@@ -41,11 +41,9 @@ void AS7341Component::dump_config() {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);
   }
   LOG_UPDATE_INTERVAL(this);
-  ESP_LOGCONFIG(TAG,
-                "  Gain: %u\n"
-                "  ATIME: %u\n"
-                "  ASTEP: %u",
-                get_gain(), get_atime(), get_astep());
+  ESP_LOGCONFIG(TAG, "  Gain: %u", get_gain());
+  ESP_LOGCONFIG(TAG, "  ATIME: %u", get_atime());
+  ESP_LOGCONFIG(TAG, "  ASTEP: %u", get_astep());
 
   LOG_SENSOR("  ", "F1", this->f1_);
   LOG_SENSOR("  ", "F2", this->f2_);

esphome/components/at581x/at581x.cpp

@@ -75,18 +75,15 @@ void AT581XComponent::setup() { ESP_LOGCONFIG(TAG, "Running setup"); }
 void AT581XComponent::dump_config() { LOG_I2C_DEVICE(this); }
 #define ARRAY_SIZE(X) (sizeof(X) / sizeof((X)[0]))
 bool AT581XComponent::i2c_write_config() {
-  ESP_LOGCONFIG(TAG,
-                "Writing new config for AT581X\n"
-                "Frequency: %dMHz\n"
-                "Sensing distance: %d\n"
-                "Power: %dµA\n"
-                "Gain: %d\n"
-                "Trigger base time: %dms\n"
-                "Trigger keep time: %dms\n"
-                "Protect time: %dms\n"
-                "Self check time: %dms",
-                this->freq_, this->delta_, this->power_, this->gain_, this->trigger_base_time_ms_,
-                this->trigger_keep_time_ms_, this->protect_time_ms_, this->self_check_time_ms_);
+  ESP_LOGCONFIG(TAG, "Writing new config for AT581X");
+  ESP_LOGCONFIG(TAG, "Frequency: %dMHz", this->freq_);
+  ESP_LOGCONFIG(TAG, "Sensing distance: %d", this->delta_);
+  ESP_LOGCONFIG(TAG, "Power: %dµA", this->power_);
+  ESP_LOGCONFIG(TAG, "Gain: %d", this->gain_);
+  ESP_LOGCONFIG(TAG, "Trigger base time: %dms", this->trigger_base_time_ms_);
+  ESP_LOGCONFIG(TAG, "Trigger keep time: %dms", this->trigger_keep_time_ms_);
+  ESP_LOGCONFIG(TAG, "Protect time: %dms", this->protect_time_ms_);
+  ESP_LOGCONFIG(TAG, "Self check time: %dms", this->self_check_time_ms_);
 
   // Set frequency point
   if (!this->i2c_write_reg(FREQ_ADDR, GAIN61_VALUE)) {

esphome/components/axs15231/touchscreen/axs15231_touchscreen.cpp

@@ -60,10 +60,8 @@ void AXS15231Touchscreen::dump_config() {
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  Width: %d\n"
-                "  Height: %d",
-                this->x_raw_max_, this->y_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Width: %d", this->x_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Height: %d", this->y_raw_max_);
 }
 
 }  // namespace axs15231

esphome/components/bang_bang/bang_bang_climate.cpp

@@ -194,14 +194,11 @@ Trigger<> *BangBangClimate::get_heat_trigger() const { return this->heat_trigger
 void BangBangClimate::set_supports_heat(bool supports_heat) { this->supports_heat_ = supports_heat; }
 void BangBangClimate::dump_config() {
   LOG_CLIMATE("", "Bang Bang Climate", this);
-  ESP_LOGCONFIG(TAG,
-                "  Supports HEAT: %s\n"
-                "  Supports COOL: %s\n"
-                "  Supports AWAY mode: %s\n"
-                "  Default Target Temperature Low: %.2f°C\n"
-                "  Default Target Temperature High: %.2f°C",
-                YESNO(this->supports_heat_), YESNO(this->supports_cool_), YESNO(this->supports_away_),
-                this->normal_config_.default_temperature_low, this->normal_config_.default_temperature_high);
+  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
+  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
+  ESP_LOGCONFIG(TAG, "  Supports AWAY mode: %s", YESNO(this->supports_away_));
+  ESP_LOGCONFIG(TAG, "  Default Target Temperature Low: %.2f°C", this->normal_config_.default_temperature_low);
+  ESP_LOGCONFIG(TAG, "  Default Target Temperature High: %.2f°C", this->normal_config_.default_temperature_high);
 }
 
 BangBangClimateTargetTempConfig::BangBangClimateTargetTempConfig() = default;

esphome/components/bedjet/bedjet_hub.cpp

@@ -484,11 +484,9 @@ void BedJetHub::loop() {}
 void BedJetHub::update() { this->dispatch_status_(); }
 
 void BedJetHub::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "BedJet Hub '%s'\n"
-                "  ble_client.app_id: %d\n"
-                "  ble_client.conn_id: %d",
-                this->get_name().c_str(), this->parent()->app_id, this->parent()->get_conn_id());
+  ESP_LOGCONFIG(TAG, "BedJet Hub '%s'", this->get_name().c_str());
+  ESP_LOGCONFIG(TAG, "  ble_client.app_id: %d", this->parent()->app_id);
+  ESP_LOGCONFIG(TAG, "  ble_client.conn_id: %d", this->parent()->get_conn_id());
   LOG_UPDATE_INTERVAL(this)
   ESP_LOGCONFIG(TAG, "  Child components (%d):", this->children_.size());
   for (auto *child : this->children_) {

esphome/components/beken_spi_led_strip/led_strip.cpp

@@ -345,10 +345,8 @@ light::ESPColorView BekenSPILEDStripLightOutput::get_view_internal(int32_t index
 }
 
 void BekenSPILEDStripLightOutput::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Beken SPI LED Strip:\n"
-                "  Pin: %u",
-                this->pin_);
+  ESP_LOGCONFIG(TAG, "Beken SPI LED Strip:");
+  ESP_LOGCONFIG(TAG, "  Pin: %u", this->pin_);
   const char *rgb_order;
   switch (this->rgb_order_) {
     case ORDER_RGB:
@@ -373,11 +371,9 @@ void BekenSPILEDStripLightOutput::dump_config() {
       rgb_order = "UNKNOWN";
       break;
   }
-  ESP_LOGCONFIG(TAG,
-                "  RGB Order: %s\n"
-                "  Max refresh rate: %" PRIu32 "\n"
-                "  Number of LEDs: %u",
-                rgb_order, *this->max_refresh_rate_, this->num_leds_);
+  ESP_LOGCONFIG(TAG, "  RGB Order: %s", rgb_order);
+  ESP_LOGCONFIG(TAG, "  Max refresh rate: %" PRIu32, *this->max_refresh_rate_);
+  ESP_LOGCONFIG(TAG, "  Number of LEDs: %u", this->num_leds_);
 }
 
 float BekenSPILEDStripLightOutput::get_setup_priority() const { return setup_priority::HARDWARE; }

esphome/components/binary_sensor/__init__.py

@@ -554,7 +554,6 @@ async def register_binary_sensor(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_binary_sensor(var))
-    CORE.register_platform_component("binary_sensor", var)
     await setup_binary_sensor_core_(var, config)
 
 

esphome/components/bl0942/bl0942.cpp

@@ -196,17 +196,14 @@ void BL0942::received_package_(DataPacket *data) {
 }
 
 void BL0942::dump_config() {  // NOLINT(readability-function-cognitive-complexity)
-  ESP_LOGCONFIG(TAG,
-                "BL0942:\n"
-                "  Reset: %s\n"
-                "  Address: %d\n"
-                "  Nominal line frequency: %d Hz\n"
-                "  Current reference: %f\n"
-                "  Energy reference: %f\n"
-                "  Power reference: %f\n"
-                "  Voltage reference: %f",
-                TRUEFALSE(this->reset_), this->address_, this->line_freq_, this->current_reference_,
-                this->energy_reference_, this->power_reference_, this->voltage_reference_);
+  ESP_LOGCONFIG(TAG, "BL0942:");
+  ESP_LOGCONFIG(TAG, "  Reset: %s", TRUEFALSE(this->reset_));
+  ESP_LOGCONFIG(TAG, "  Address: %d", this->address_);
+  ESP_LOGCONFIG(TAG, "  Nominal line frequency: %d Hz", this->line_freq_);
+  ESP_LOGCONFIG(TAG, "  Current reference: %f", this->current_reference_);
+  ESP_LOGCONFIG(TAG, "  Energy reference: %f", this->energy_reference_);
+  ESP_LOGCONFIG(TAG, "  Power reference: %f", this->power_reference_);
+  ESP_LOGCONFIG(TAG, "  Voltage reference: %f", this->voltage_reference_);
   LOG_SENSOR("", "Voltage", this->voltage_sensor_);
   LOG_SENSOR("", "Current", this->current_sensor_);
   LOG_SENSOR("", "Power", this->power_sensor_);

esphome/components/ble_client/__init__.py

@@ -1,8 +1,7 @@
 from esphome import automation
 from esphome.automation import maybe_simple_id
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
-from esphome.components.esp32_ble import BTLoggers
+from esphome.components import esp32_ble_client, esp32_ble_tracker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_CHARACTERISTIC_UUID,
@@ -288,9 +287,6 @@ async def remove_bond_to_code(config, action_id, template_arg, args):
 
 
 async def to_code(config):
-    # Register the loggers this component needs
-    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
     await esp32_ble_tracker.register_client(var, config)

esphome/components/ble_client/output/ble_binary_output.cpp

@@ -10,12 +10,9 @@ static const char *const TAG = "ble_binary_output";
 
 void BLEBinaryOutput::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Binary Output:");
-  ESP_LOGCONFIG(TAG,
-                "  MAC address        : %s\n"
-                "  Service UUID       : %s\n"
-                "  Characteristic UUID: %s",
-                this->parent_->address_str().c_str(), this->service_uuid_.to_string().c_str(),
-                this->char_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent_->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
   LOG_BINARY_OUTPUT(this);
 }
 

esphome/components/ble_client/sensor/ble_sensor.cpp

@@ -1,7 +1,7 @@
 #include "ble_sensor.h"
+#include "esphome/core/log.h"
 #include "esphome/core/application.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 #include "esphome/components/esp32_ble_tracker/esp32_ble_tracker.h"
 
 #ifdef USE_ESP32
@@ -15,14 +15,11 @@ void BLESensor::loop() {}
 
 void BLESensor::dump_config() {
   LOG_SENSOR("", "BLE Sensor", this);
-  ESP_LOGCONFIG(TAG,
-                "  MAC address        : %s\n"
-                "  Service UUID       : %s\n"
-                "  Characteristic UUID: %s\n"
-                "  Descriptor UUID    : %s\n"
-                "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
-                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Descriptor UUID    : %s", this->descr_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Notifications      : %s", YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/ble_client/text_sensor/ble_text_sensor.cpp

@@ -18,14 +18,11 @@ void BLETextSensor::loop() {}
 
 void BLETextSensor::dump_config() {
   LOG_TEXT_SENSOR("", "BLE Text Sensor", this);
-  ESP_LOGCONFIG(TAG,
-                "  MAC address        : %s\n"
-                "  Service UUID       : %s\n"
-                "  Characteristic UUID: %s\n"
-                "  Descriptor UUID    : %s\n"
-                "  Notifications      : %s",
-                this->parent()->address_str().c_str(), this->service_uuid_.to_string().c_str(),
-                this->char_uuid_.to_string().c_str(), this->descr_uuid_.to_string().c_str(), YESNO(this->notify_));
+  ESP_LOGCONFIG(TAG, "  MAC address        : %s", this->parent()->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Service UUID       : %s", this->service_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Characteristic UUID: %s", this->char_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Descriptor UUID    : %s", this->descr_uuid_.to_string().c_str());
+  ESP_LOGCONFIG(TAG, "  Notifications      : %s", YESNO(this->notify_));
   LOG_UPDATE_INTERVAL(this);
 }
 

esphome/components/bluetooth_proxy/__init__.py

@@ -1,7 +1,6 @@
 import esphome.codegen as cg
-from esphome.components import esp32_ble, esp32_ble_client, esp32_ble_tracker
+from esphome.components import esp32_ble_client, esp32_ble_tracker
 from esphome.components.esp32 import add_idf_sdkconfig_option
-from esphome.components.esp32_ble import BTLoggers
 import esphome.config_validation as cv
 from esphome.const import CONF_ACTIVE, CONF_ID
 
@@ -78,9 +77,6 @@ CONFIG_SCHEMA = cv.All(
 
 
 async def to_code(config):
-    # Register the loggers this component needs
-    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.L2CAP, BTLoggers.SMP)
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -146,11 +146,9 @@ void BluetoothProxy::send_api_packet_(const esp32_ble_tracker::ESPBTDevice &devi
 
 void BluetoothProxy::dump_config() {
   ESP_LOGCONFIG(TAG, "Bluetooth Proxy:");
-  ESP_LOGCONFIG(TAG,
-                "  Active: %s\n"
-                "  Connections: %d\n"
-                "  Raw advertisements: %s",
-                YESNO(this->active_), this->connections_.size(), YESNO(this->raw_advertisements_));
+  ESP_LOGCONFIG(TAG, "  Active: %s", YESNO(this->active_));
+  ESP_LOGCONFIG(TAG, "  Connections: %d", this->connections_.size());
+  ESP_LOGCONFIG(TAG, "  Raw advertisements: %s", YESNO(this->raw_advertisements_));
 }
 
 int BluetoothProxy::get_bluetooth_connections_free() {

esphome/components/bme680_bsec/bme680_bsec.cpp

@@ -1,6 +1,6 @@
 #include "bme680_bsec.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 #include <string>
 
 namespace esphome {
@@ -159,15 +159,11 @@ void BME680BSECComponent::dump_config() {
              this->bme680_status_);
   }
 
-  ESP_LOGCONFIG(TAG,
-                "  Temperature Offset: %.2f\n"
-                "  IAQ Mode: %s\n"
-                "  Supply Voltage: %sV\n"
-                "  Sample Rate: %s\n"
-                "  State Save Interval: %ims",
-                this->temperature_offset_, this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile",
-                this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? "3.3" : "1.8",
-                BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_), this->state_save_interval_ms_);
+  ESP_LOGCONFIG(TAG, "  Temperature Offset: %.2f", this->temperature_offset_);
+  ESP_LOGCONFIG(TAG, "  IAQ Mode: %s", this->iaq_mode_ == IAQ_MODE_STATIC ? "Static" : "Mobile");
+  ESP_LOGCONFIG(TAG, "  Supply Voltage: %sV", this->supply_voltage_ == SUPPLY_VOLTAGE_3V3 ? "3.3" : "1.8");
+  ESP_LOGCONFIG(TAG, "  Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->sample_rate_));
+  ESP_LOGCONFIG(TAG, "  State Save Interval: %ims", this->state_save_interval_ms_);
 
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
   ESP_LOGCONFIG(TAG, "    Sample Rate: %s", BME680_BSEC_SAMPLE_RATE_LOG(this->temperature_sample_rate_));

esphome/components/bme68x_bsec2/bme68x_bsec2.cpp

@@ -58,13 +58,13 @@ void BME68xBSEC2Component::setup() {
 }
 
 void BME68xBSEC2Component::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "BME68X via BSEC2:\n"
-                "  BSEC2 version: %d.%d.%d.%d\n"
-                "  BSEC2 configuration blob:\n"
-                "    Configured: %s",
-                this->version_.major, this->version_.minor, this->version_.major_bugfix, this->version_.minor_bugfix,
-                YESNO(this->bsec2_blob_configured_));
+  ESP_LOGCONFIG(TAG, "BME68X via BSEC2:");
+
+  ESP_LOGCONFIG(TAG, "  BSEC2 version: %d.%d.%d.%d", this->version_.major, this->version_.minor,
+                this->version_.major_bugfix, this->version_.minor_bugfix);
+
+  ESP_LOGCONFIG(TAG, "  BSEC2 configuration blob:");
+  ESP_LOGCONFIG(TAG, "    Configured: %s", YESNO(this->bsec2_blob_configured_));
   if (this->bsec2_configuration_ != nullptr && this->bsec2_configuration_length_) {
     ESP_LOGCONFIG(TAG, "    Size: %" PRIu32, this->bsec2_configuration_length_);
   }
@@ -77,14 +77,11 @@ void BME68xBSEC2Component::dump_config() {
   if (this->algorithm_output_ != ALGORITHM_OUTPUT_IAQ) {
     ESP_LOGCONFIG(TAG, "  Algorithm output: %s", BME68X_BSEC2_ALGORITHM_OUTPUT_LOG(this->algorithm_output_));
   }
-  ESP_LOGCONFIG(TAG,
-                "  Operating age: %s\n"
-                "  Sample rate: %s\n"
-                "  Voltage: %s\n"
-                "  State save interval: %ims\n"
-                "  Temperature offset: %.2f",
-                BME68X_BSEC2_OPERATING_AGE_LOG(this->operating_age_), BME68X_BSEC2_SAMPLE_RATE_LOG(this->sample_rate_),
-                BME68X_BSEC2_VOLTAGE_LOG(this->voltage_), this->state_save_interval_ms_, this->temperature_offset_);
+  ESP_LOGCONFIG(TAG, "  Operating age: %s", BME68X_BSEC2_OPERATING_AGE_LOG(this->operating_age_));
+  ESP_LOGCONFIG(TAG, "  Sample rate: %s", BME68X_BSEC2_SAMPLE_RATE_LOG(this->sample_rate_));
+  ESP_LOGCONFIG(TAG, "  Voltage: %s", BME68X_BSEC2_VOLTAGE_LOG(this->voltage_));
+  ESP_LOGCONFIG(TAG, "  State save interval: %ims", this->state_save_interval_ms_);
+  ESP_LOGCONFIG(TAG, "  Temperature offset: %.2f", this->temperature_offset_);
 
 #ifdef USE_SENSOR
   LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);

esphome/components/bmp3xx_base/bmp3xx_base.cpp

@@ -148,10 +148,8 @@ void BMP3XXComponent::setup() {
 }
 
 void BMP3XXComponent::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "BMP3XX:\n"
-                "  Type: %s (0x%X)",
-                LOG_STR_ARG(chip_type_to_str(this->chip_id_.reg)), this->chip_id_.reg);
+  ESP_LOGCONFIG(TAG, "BMP3XX:");
+  ESP_LOGCONFIG(TAG, "  Type: %s (0x%X)", LOG_STR_ARG(chip_type_to_str(this->chip_id_.reg)), this->chip_id_.reg);
   switch (this->error_code_) {
     case NONE:
       break;

esphome/components/bmp581/bmp581.cpp

@@ -98,20 +98,14 @@ void BMP581Component::dump_config() {
 
   if (this->temperature_sensor_) {
     LOG_SENSOR("  ", "Temperature", this->temperature_sensor_);
-    ESP_LOGCONFIG(TAG,
-                  "    IIR Filter: %s\n"
-                  "    Oversampling: %s",
-                  LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)),
-                  LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
+    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_temperature_level_)));
+    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->temperature_oversampling_)));
   }
 
   if (this->pressure_sensor_) {
     LOG_SENSOR("  ", "Pressure", this->pressure_sensor_);
-    ESP_LOGCONFIG(TAG,
-                  "    IIR Filter: %s\n"
-                  "    Oversampling: %s",
-                  LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)),
-                  LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
+    ESP_LOGCONFIG(TAG, "    IIR Filter: %s", LOG_STR_ARG(iir_filter_to_str(this->iir_pressure_level_)));
+    ESP_LOGCONFIG(TAG, "    Oversampling: %s", LOG_STR_ARG(oversampling_to_str(this->pressure_oversampling_)));
   }
 }
 

esphome/components/bp1658cj/bp1658cj.cpp

@@ -26,10 +26,8 @@ void BP1658CJ::dump_config() {
   ESP_LOGCONFIG(TAG, "BP1658CJ:");
   LOG_PIN("  Data Pin: ", this->data_pin_);
   LOG_PIN("  Clock Pin: ", this->clock_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  Color Channels Max Power: %u\n"
-                "  White Channels Max Power: %u",
-                this->max_power_color_channels_, this->max_power_white_channels_);
+  ESP_LOGCONFIG(TAG, "  Color Channels Max Power: %u", this->max_power_color_channels_);
+  ESP_LOGCONFIG(TAG, "  White Channels Max Power: %u", this->max_power_white_channels_);
 }
 
 void BP1658CJ::loop() {

esphome/components/button/__init__.py

@@ -108,7 +108,6 @@ async def register_button(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_button(var))
-    CORE.register_platform_component("button", var)
     await setup_button_core_(var, config)
 
 

esphome/components/cap1188/cap1188.cpp

@@ -52,11 +52,9 @@ void CAP1188Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CAP1188:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  Product ID: 0x%x\n"
-                "  Manufacture ID: 0x%x\n"
-                "  Revision ID: 0x%x",
-                this->cap1188_product_id_, this->cap1188_manufacture_id_, this->cap1188_revision_);
+  ESP_LOGCONFIG(TAG, "  Product ID: 0x%x", this->cap1188_product_id_);
+  ESP_LOGCONFIG(TAG, "  Manufacture ID: 0x%x", this->cap1188_manufacture_id_);
+  ESP_LOGCONFIG(TAG, "  Revision ID: 0x%x", this->cap1188_revision_);
 
   switch (this->error_code_) {
     case COMMUNICATION_FAILED:

esphome/components/ccs811/ccs811.cpp

@@ -1,7 +1,6 @@
 #include "ccs811.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace ccs811 {

esphome/components/chsc6x/chsc6x_touchscreen.cpp

@@ -38,11 +38,9 @@ void CHSC6XTouchscreen::dump_config() {
   ESP_LOGCONFIG(TAG, "CHSC6X Touchscreen:");
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  Touch timeout: %d\n"
-                "  x_raw_max_: %d\n"
-                "  y_raw_max_: %d",
-                this->touch_timeout_, this->x_raw_max_, this->y_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Touch timeout: %d", this->touch_timeout_);
+  ESP_LOGCONFIG(TAG, "  x_raw_max_: %d", this->x_raw_max_);
+  ESP_LOGCONFIG(TAG, "  y_raw_max_: %d", this->y_raw_max_);
 }
 
 }  // namespace chsc6x

esphome/components/climate/__init__.py

@@ -443,7 +443,6 @@ async def register_climate(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_climate(var))
-    CORE.register_platform_component("climate", var)
     await setup_climate_core_(var, config)
 
 

esphome/components/climate/climate.cpp

@@ -569,22 +569,17 @@ bool Climate::set_custom_preset_(const std::string &preset) {
 void Climate::dump_traits_(const char *tag) {
   auto traits = this->get_traits();
   ESP_LOGCONFIG(tag, "ClimateTraits:");
-  ESP_LOGCONFIG(tag,
-                "  [x] Visual settings:\n"
-                "      - Min temperature: %.1f\n"
-                "      - Max temperature: %.1f\n"
-                "      - Temperature step:\n"
-                "          Target: %.1f",
-                traits.get_visual_min_temperature(), traits.get_visual_max_temperature(),
-                traits.get_visual_target_temperature_step());
+  ESP_LOGCONFIG(tag, "  [x] Visual settings:");
+  ESP_LOGCONFIG(tag, "      - Min temperature: %.1f", traits.get_visual_min_temperature());
+  ESP_LOGCONFIG(tag, "      - Max temperature: %.1f", traits.get_visual_max_temperature());
+  ESP_LOGCONFIG(tag, "      - Temperature step:");
+  ESP_LOGCONFIG(tag, "          Target: %.1f", traits.get_visual_target_temperature_step());
   if (traits.get_supports_current_temperature()) {
     ESP_LOGCONFIG(tag, "          Current: %.1f", traits.get_visual_current_temperature_step());
   }
   if (traits.get_supports_target_humidity() || traits.get_supports_current_humidity()) {
-    ESP_LOGCONFIG(tag,
-                  "      - Min humidity: %.0f\n"
-                  "      - Max humidity: %.0f",
-                  traits.get_visual_min_humidity(), traits.get_visual_max_humidity());
+    ESP_LOGCONFIG(tag, "      - Min humidity: %.0f", traits.get_visual_min_humidity());
+    ESP_LOGCONFIG(tag, "      - Max humidity: %.0f", traits.get_visual_max_humidity());
   }
   if (traits.get_supports_two_point_target_temperature()) {
     ESP_LOGCONFIG(tag, "  [x] Supports two-point target temperature");

esphome/components/climate/climate.h

@@ -3,8 +3,8 @@
 #include "esphome/core/component.h"
 #include "esphome/core/entity_base.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 #include "esphome/core/preferences.h"
+#include "esphome/core/log.h"
 #include "climate_mode.h"
 #include "climate_traits.h"
 

esphome/components/climate_ir/climate_ir.cpp

@@ -75,13 +75,10 @@ void ClimateIR::control(const climate::ClimateCall &call) {
 }
 void ClimateIR::dump_config() {
   LOG_CLIMATE("", "IR Climate", this);
-  ESP_LOGCONFIG(TAG,
-                "  Min. Temperature: %.1f°C\n"
-                "  Max. Temperature: %.1f°C\n"
-                "  Supports HEAT: %s\n"
-                "  Supports COOL: %s",
-                this->minimum_temperature_, this->maximum_temperature_, YESNO(this->supports_heat_),
-                YESNO(this->supports_cool_));
+  ESP_LOGCONFIG(TAG, "  Min. Temperature: %.1f°C", this->minimum_temperature_);
+  ESP_LOGCONFIG(TAG, "  Max. Temperature: %.1f°C", this->maximum_temperature_);
+  ESP_LOGCONFIG(TAG, "  Supports HEAT: %s", YESNO(this->supports_heat_));
+  ESP_LOGCONFIG(TAG, "  Supports COOL: %s", YESNO(this->supports_cool_));
 }
 
 }  // namespace climate_ir

esphome/components/cover/__init__.py

@@ -189,7 +189,6 @@ async def register_cover(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_cover(var))
-    CORE.register_platform_component("cover", var)
     await setup_cover_core_(var, config)
 
 

esphome/components/cs5460a/cs5460a.cpp

@@ -319,23 +319,18 @@ bool CS5460AComponent::check_status_() {
 void CS5460AComponent::dump_config() {
   uint32_t state = this->get_component_state();
 
-  ESP_LOGCONFIG(TAG,
-                "CS5460A:\n"
-                "  Init status: %s",
+  ESP_LOGCONFIG(TAG, "CS5460A:");
+  ESP_LOGCONFIG(TAG, "  Init status: %s",
                 state == COMPONENT_STATE_LOOP ? "OK" : (state == COMPONENT_STATE_FAILED ? "failed" : "other"));
   LOG_PIN("  CS Pin: ", cs_);
-  ESP_LOGCONFIG(TAG,
-                "  Samples / cycle: %" PRIu32 "\n"
-                "  Phase offset: %i\n"
-                "  PGA Gain: %s\n"
-                "  Current gain: %.5f\n"
-                "  Voltage gain: %.5f\n"
-                "  Current HPF: %s\n"
-                "  Voltage HPF: %s\n"
-                "  Pulse energy: %.2f Wh",
-                samples_, phase_offset_, pga_gain_ == CS5460A_PGA_GAIN_50X ? "50x" : "10x", current_gain_,
-                voltage_gain_, current_hpf_ ? "enabled" : "disabled", voltage_hpf_ ? "enabled" : "disabled",
-                pulse_energy_wh_);
+  ESP_LOGCONFIG(TAG, "  Samples / cycle: %" PRIu32, samples_);
+  ESP_LOGCONFIG(TAG, "  Phase offset: %i", phase_offset_);
+  ESP_LOGCONFIG(TAG, "  PGA Gain: %s", pga_gain_ == CS5460A_PGA_GAIN_50X ? "50x" : "10x");
+  ESP_LOGCONFIG(TAG, "  Current gain: %.5f", current_gain_);
+  ESP_LOGCONFIG(TAG, "  Voltage gain: %.5f", voltage_gain_);
+  ESP_LOGCONFIG(TAG, "  Current HPF: %s", current_hpf_ ? "enabled" : "disabled");
+  ESP_LOGCONFIG(TAG, "  Voltage HPF: %s", voltage_hpf_ ? "enabled" : "disabled");
+  ESP_LOGCONFIG(TAG, "  Pulse energy: %.2f Wh", pulse_energy_wh_);
   LOG_SENSOR("  ", "Voltage", voltage_sensor_);
   LOG_SENSOR("  ", "Current", current_sensor_);
   LOG_SENSOR("  ", "Power", power_sensor_);

esphome/components/cse7766/cse7766.cpp

@@ -223,6 +223,11 @@ void CSE7766Component::parse_data_() {
 #endif
 }
 
+uint32_t CSE7766Component::get_24_bit_uint_(uint8_t start_index) {
+  return (uint32_t(this->raw_data_[start_index]) << 16) | (uint32_t(this->raw_data_[start_index + 1]) << 8) |
+         uint32_t(this->raw_data_[start_index + 2]);
+}
+
 void CSE7766Component::dump_config() {
   ESP_LOGCONFIG(TAG, "CSE7766:");
   LOG_SENSOR("  ", "Voltage", this->voltage_sensor_);

esphome/components/cse7766/cse7766.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "esphome/core/component.h"
-#include "esphome/core/helpers.h"
 #include "esphome/components/sensor/sensor.h"
 #include "esphome/components/uart/uart.h"
 
@@ -29,10 +28,7 @@ class CSE7766Component : public Component, public uart::UARTDevice {
  protected:
   bool check_byte_();
   void parse_data_();
-  uint32_t get_24_bit_uint_(uint8_t start_index) const {
-    return encode_uint24(this->raw_data_[start_index], this->raw_data_[start_index + 1],
-                         this->raw_data_[start_index + 2]);
-  }
+  uint32_t get_24_bit_uint_(uint8_t start_index);
 
   uint8_t raw_data_[24];
   uint8_t raw_data_index_{0};

esphome/components/cst816/touchscreen/cst816_touchscreen.cpp

@@ -1,5 +1,4 @@
 #include "cst816_touchscreen.h"
-#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace cst816 {
@@ -75,10 +74,8 @@ void CST816Touchscreen::dump_config() {
   LOG_I2C_DEVICE(this);
   LOG_PIN("  Interrupt Pin: ", this->interrupt_pin_);
   LOG_PIN("  Reset Pin: ", this->reset_pin_);
-  ESP_LOGCONFIG(TAG,
-                "  X Raw Min: %d, X Raw Max: %d\n"
-                "  Y Raw Min: %d, Y Raw Max: %d",
-                this->x_raw_min_, this->x_raw_max_, this->y_raw_min_, this->y_raw_max_);
+  ESP_LOGCONFIG(TAG, "  X Raw Min: %d, X Raw Max: %d", this->x_raw_min_, this->x_raw_max_);
+  ESP_LOGCONFIG(TAG, "  Y Raw Min: %d, Y Raw Max: %d", this->y_raw_min_, this->y_raw_max_);
   const char *name;
   switch (this->chip_id_) {
     case CST820_CHIP_ID:

esphome/components/current_based/current_based_cover.cpp

@@ -151,10 +151,8 @@ void CurrentBasedCover::dump_config() {
   if (this->max_duration_ != UINT32_MAX) {
     ESP_LOGCONFIG(TAG, "Maximum duration: %.1fs", this->max_duration_ / 1e3f);
   }
-  ESP_LOGCONFIG(TAG,
-                "Start sensing delay: %.1fs\n"
-                "Malfunction detection: %s",
-                this->start_sensing_delay_ / 1e3f, YESNO(this->malfunction_detection_));
+  ESP_LOGCONFIG(TAG, "Start sensing delay: %.1fs", this->start_sensing_delay_ / 1e3f);
+  ESP_LOGCONFIG(TAG, "Malfunction detection: %s", YESNO(this->malfunction_detection_));
 }
 
 float CurrentBasedCover::get_setup_priority() const { return setup_priority::DATA; }

esphome/components/dac7678/dac7678_output.cpp

@@ -1,7 +1,7 @@
 #include "dac7678_output.h"
-#include "esphome/core/hal.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
 
 namespace esphome {
 namespace dac7678 {

esphome/components/daly_bms/daly_bms.cpp

@@ -1,8 +1,7 @@
 #include "daly_bms.h"
 #include <vector>
-#include "esphome/core/application.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/application.h"
 
 namespace esphome {
 namespace daly_bms {

esphome/components/datetime/__init__.py

@@ -158,9 +158,7 @@ async def setup_datetime_core_(var, config):
 async def register_datetime(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
-    entity_type = config[CONF_TYPE].lower()
-    cg.add(getattr(cg.App, f"register_{entity_type}")(var))
-    CORE.register_platform_component(entity_type, var)
+    cg.add(getattr(cg.App, f"register_{config[CONF_TYPE].lower()}")(var))
     await setup_datetime_core_(var, config)
     cg.add_define(f"USE_DATETIME_{config[CONF_TYPE]}")
 

esphome/components/debug/debug_component.cpp

@@ -2,9 +2,9 @@
 
 #include <algorithm>
 #include "esphome/core/application.h"
+#include "esphome/core/log.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
-#include "esphome/core/log.h"
 #include "esphome/core/version.h"
 #include <cinttypes>
 #include <climits>

esphome/components/debug/debug_component.h

@@ -2,8 +2,8 @@
 
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/macros.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_SENSOR
 #include "esphome/components/sensor/sensor.h"

esphome/components/debug/debug_esp32.cpp

@@ -107,10 +107,8 @@ std::string DebugComponent::get_wakeup_cause_() {
 }
 
 void DebugComponent::log_partition_info_() {
-  ESP_LOGCONFIG(TAG,
-                "Partition table:\n"
-                "  %-12s %-4s %-8s %-10s %-10s",
-                "Name", "Type", "Subtype", "Address", "Size");
+  ESP_LOGCONFIG(TAG, "Partition table:");
+  ESP_LOGCONFIG(TAG, "  %-12s %-4s %-8s %-10s %-10s", "Name", "Type", "Subtype", "Address", "Size");
   esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
   while (it != NULL) {
     const esp_partition_t *partition = esp_partition_get(it);

esphome/components/deep_sleep/deep_sleep_component.cpp

@@ -6,8 +6,6 @@ namespace esphome {
 namespace deep_sleep {
 
 static const char *const TAG = "deep_sleep";
-// 5 seconds for deep sleep to ensure clean disconnect from Home Assistant
-static const uint32_t TEARDOWN_TIMEOUT_DEEP_SLEEP_MS = 5000;
 
 bool global_has_deep_sleep = false;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
@@ -64,10 +62,6 @@ void DeepSleepComponent::begin_sleep(bool manual) {
     ESP_LOGI(TAG, "Sleeping for %" PRId64 "us", *this->sleep_duration_);
   }
   App.run_safe_shutdown_hooks();
-  // It's critical to teardown components cleanly for deep sleep to ensure
-  // Home Assistant sees a clean disconnect instead of marking the device unavailable
-  App.teardown_components(TEARDOWN_TIMEOUT_DEEP_SLEEP_MS);
-  App.run_powerdown_hooks();
 
   this->deep_sleep_();
 }

esphome/components/deep_sleep/deep_sleep_esp32.cpp

@@ -46,12 +46,10 @@ void DeepSleepComponent::dump_config_platform_() {
     LOG_PIN("  Wakeup Pin: ", this->wakeup_pin_);
   }
   if (this->wakeup_cause_to_run_duration_.has_value()) {
-    ESP_LOGCONFIG(TAG,
-                  "  Default Wakeup Run Duration: %" PRIu32 " ms\n"
-                  "  Touch Wakeup Run Duration: %" PRIu32 " ms\n"
-                  "  GPIO Wakeup Run Duration: %" PRIu32 " ms",
-                  this->wakeup_cause_to_run_duration_->default_cause, this->wakeup_cause_to_run_duration_->touch_cause,
-                  this->wakeup_cause_to_run_duration_->gpio_cause);
+    ESP_LOGCONFIG(TAG, "  Default Wakeup Run Duration: %" PRIu32 " ms",
+                  this->wakeup_cause_to_run_duration_->default_cause);
+    ESP_LOGCONFIG(TAG, "  Touch Wakeup Run Duration: %" PRIu32 " ms", this->wakeup_cause_to_run_duration_->touch_cause);
+    ESP_LOGCONFIG(TAG, "  GPIO Wakeup Run Duration: %" PRIu32 " ms", this->wakeup_cause_to_run_duration_->gpio_cause);
   }
 }
 

esphome/components/dht/dht.cpp

@@ -1,6 +1,6 @@
 #include "dht.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace dht {

esphome/components/display/display.h

@@ -182,11 +182,9 @@ using display_writer_t = std::function<void(Display &)>;
 
 #define LOG_DISPLAY(prefix, type, obj) \
   if ((obj) != nullptr) { \
-    ESP_LOGCONFIG(TAG, \
-                  prefix type "\n" \
-                              "%s  Rotations: %d °\n" \
-                              "%s  Dimensions: %dpx x %dpx", \
-                  prefix, (obj)->rotation_, prefix, (obj)->get_width(), (obj)->get_height()); \
+    ESP_LOGCONFIG(TAG, prefix type); \
+    ESP_LOGCONFIG(TAG, "%s  Rotations: %d °", prefix, (obj)->rotation_); \
+    ESP_LOGCONFIG(TAG, "%s  Dimensions: %dpx x %dpx", prefix, (obj)->get_width(), (obj)->get_height()); \
   }
 
 /// Turn the pixel OFF.

esphome/components/dps310/dps310.cpp

@@ -86,11 +86,9 @@ void DPS310Component::setup() {
 }
 
 void DPS310Component::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "DPS310:\n"
-                "  Product ID: %u\n"
-                "  Revision ID: %u",
-                this->prod_rev_id_ & 0x0F, (this->prod_rev_id_ >> 4) & 0x0F);
+  ESP_LOGCONFIG(TAG, "DPS310:");
+  ESP_LOGCONFIG(TAG, "  Product ID: %u", this->prod_rev_id_ & 0x0F);
+  ESP_LOGCONFIG(TAG, "  Revision ID: %u", (this->prod_rev_id_ >> 4) & 0x0F);
   LOG_I2C_DEVICE(this);
   if (this->is_failed()) {
     ESP_LOGE(TAG, ESP_LOG_MSG_COMM_FAIL);

esphome/components/dsmr/dsmr.cpp

@@ -278,11 +278,9 @@ bool Dsmr::parse_telegram() {
 }
 
 void Dsmr::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "DSMR:\n"
-                "  Max telegram length: %d\n"
-                "  Receive timeout: %.1fs",
-                this->max_telegram_len_, this->receive_timeout_ / 1e3f);
+  ESP_LOGCONFIG(TAG, "DSMR:");
+  ESP_LOGCONFIG(TAG, "  Max telegram length: %d", this->max_telegram_len_);
+  ESP_LOGCONFIG(TAG, "  Receive timeout: %.1fs", this->receive_timeout_ / 1e3f);
   if (this->request_pin_ != nullptr) {
     LOG_PIN("  Request Pin: ", this->request_pin_);
   }

esphome/components/duty_cycle/duty_cycle_sensor.cpp

@@ -1,6 +1,6 @@
 #include "duty_cycle_sensor.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace duty_cycle {

esphome/components/duty_time/duty_time_sensor.cpp

@@ -94,11 +94,9 @@ void DutyTimeSensor::publish_and_save_(const uint32_t sec, const uint32_t ms) {
 }
 
 void DutyTimeSensor::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "Duty Time:\n"
-                "  Update Interval: %" PRId32 "ms\n"
-                "  Restore: %s",
-                this->get_update_interval(), ONOFF(this->restore_));
+  ESP_LOGCONFIG(TAG, "Duty Time:");
+  ESP_LOGCONFIG(TAG, "  Update Interval: %" PRId32 "ms", this->get_update_interval());
+  ESP_LOGCONFIG(TAG, "  Restore: %s", ONOFF(this->restore_));
   LOG_SENSOR("  ", "Duty Time Sensor:", this);
   LOG_SENSOR("  ", "Last Duty Time Sensor:", this->last_duty_time_sensor_);
 }

esphome/components/ee895/ee895.cpp

@@ -1,6 +1,6 @@
 #include "ee895.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 namespace esphome {
 namespace ee895 {

esphome/components/emc2101/emc2101.cpp

@@ -100,10 +100,8 @@ void Emc2101Component::dump_config() {
   if (this->dac_mode_) {
     ESP_LOGCONFIG(TAG, "  DAC Conversion Rate: %X", this->dac_conversion_rate_);
   } else {
-    ESP_LOGCONFIG(TAG,
-                  "  PWM Resolution: %02X\n"
-                  "  PWM Divider: %02X",
-                  this->pwm_resolution_, this->pwm_divider_);
+    ESP_LOGCONFIG(TAG, "  PWM Resolution: %02X", this->pwm_resolution_);
+    ESP_LOGCONFIG(TAG, "  PWM Divider: %02X", this->pwm_divider_);
   }
   ESP_LOGCONFIG(TAG, "  Inverted: %s", YESNO(this->inverted_));
 }

esphome/components/es7210/es7210.cpp

@@ -25,11 +25,9 @@ static const size_t MCLK_DIV_FRE = 256;
   }
 
 void ES7210::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ES7210 audio ADC:\n"
-                "  Bits Per Sample: %" PRIu8 "\n"
-                "  Sample Rate: %" PRIu32,
-                this->bits_per_sample_, this->sample_rate_);
+  ESP_LOGCONFIG(TAG, "ES7210 audio ADC:");
+  ESP_LOGCONFIG(TAG, "  Bits Per Sample: %" PRIu8, this->bits_per_sample_);
+  ESP_LOGCONFIG(TAG, "  Sample Rate: %" PRIu32, this->sample_rate_);
 
   if (this->is_failed()) {
     ESP_LOGE(TAG, "  Failed to initialize");

esphome/components/es8311/es8311.cpp

@@ -52,13 +52,11 @@ void ES8311::setup() {
 }
 
 void ES8311::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ES8311 Audio Codec:\n"
-                "  Use MCLK: %s\n"
-                "  Use Microphone: %s\n"
-                "  DAC Bits per Sample: %" PRIu8 "\n"
-                "  Sample Rate: %" PRIu32,
-                YESNO(this->use_mclk_), YESNO(this->use_mic_), this->resolution_out_, this->sample_frequency_);
+  ESP_LOGCONFIG(TAG, "ES8311 Audio Codec:");
+  ESP_LOGCONFIG(TAG, "  Use MCLK: %s", YESNO(this->use_mclk_));
+  ESP_LOGCONFIG(TAG, "  Use Microphone: %s", YESNO(this->use_mic_));
+  ESP_LOGCONFIG(TAG, "  DAC Bits per Sample: %" PRIu8, this->resolution_out_);
+  ESP_LOGCONFIG(TAG, "  Sample Rate: %" PRIu32, this->sample_frequency_);
 
   if (this->is_failed()) {
     ESP_LOGCONFIG(TAG, "  Failed to initialize!");

esphome/components/esp32/__init__.py

@@ -71,28 +71,12 @@ from .const import (  # noqa
 from .gpio import esp32_pin_to_code  # noqa
 
 _LOGGER = logging.getLogger(__name__)
-AUTO_LOAD = ["preferences"]
 CODEOWNERS = ["@esphome/core"]
+AUTO_LOAD = ["preferences"]
 IS_TARGET_PLATFORM = True
 
-CONF_ASSERTION_LEVEL = "assertion_level"
-CONF_COMPILER_OPTIMIZATION = "compiler_optimization"
-CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
-CONF_ENABLE_LWIP_ASSERT = "enable_lwip_assert"
 CONF_RELEASE = "release"
-
-ASSERTION_LEVELS = {
-    "DISABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_DISABLE",
-    "ENABLE": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_ENABLE",
-    "SILENT": "CONFIG_COMPILER_OPTIMIZATION_ASSERTIONS_SILENT",
-}
-
-COMPILER_OPTIMIZATIONS = {
-    "DEBUG": "CONFIG_COMPILER_OPTIMIZATION_DEBUG",
-    "NONE": "CONFIG_COMPILER_OPTIMIZATION_NONE",
-    "PERF": "CONFIG_COMPILER_OPTIMIZATION_PERF",
-    "SIZE": "CONFIG_COMPILER_OPTIMIZATION_SIZE",
-}
+CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES = "enable_idf_experimental_features"
 
 
 def get_cpu_frequencies(*frequencies):
@@ -467,8 +451,8 @@ def _parse_platform_version(value):
         if ver.major >= 50:  # a pioarduino version
             if "-" in value:
                 # maybe a release candidate?...definitely not our default, just use it as-is...
-                return f"https://github.com/pioarduino/platform-espressif32/releases/download/{value}/platform-espressif32.zip"
-            return f"https://github.com/pioarduino/platform-espressif32/releases/download/{ver.major}.{ver.minor:02d}.{ver.patch:02d}/platform-espressif32.zip"
+                return f"https://github.com/pioarduino/platform-espressif32.git#{value}"
+            return f"https://github.com/pioarduino/platform-espressif32.git#{ver.major}.{ver.minor:02d}.{ver.patch:02d}"
         # if platform version is a valid version constraint, prefix the default package
         cv.platformio_version_constraint(value)
         return f"platformio/espressif32@{value}"
@@ -558,10 +542,6 @@ ARDUINO_FRAMEWORK_SCHEMA = cv.All(
 )
 
 CONF_SDKCONFIG_OPTIONS = "sdkconfig_options"
-CONF_ENABLE_LWIP_DHCP_SERVER = "enable_lwip_dhcp_server"
-CONF_ENABLE_LWIP_MDNS_QUERIES = "enable_lwip_mdns_queries"
-CONF_ENABLE_LWIP_BRIDGE_INTERFACE = "enable_lwip_bridge_interface"
-
 ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
     cv.Schema(
         {
@@ -574,30 +554,11 @@ ESP_IDF_FRAMEWORK_SCHEMA = cv.All(
             },
             cv.Optional(CONF_ADVANCED, default={}): cv.Schema(
                 {
-                    cv.Optional(CONF_ASSERTION_LEVEL): cv.one_of(
-                        *ASSERTION_LEVELS, upper=True
-                    ),
-                    cv.Optional(CONF_COMPILER_OPTIMIZATION, default="SIZE"): cv.one_of(
-                        *COMPILER_OPTIMIZATIONS, upper=True
-                    ),
-                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
-                    cv.Optional(CONF_ENABLE_LWIP_ASSERT, default=True): cv.boolean,
                     cv.Optional(
                         CONF_IGNORE_EFUSE_CUSTOM_MAC, default=False
                     ): cv.boolean,
                     cv.Optional(CONF_IGNORE_EFUSE_MAC_CRC): cv.boolean,
-                    # DHCP server is needed for WiFi AP mode. When WiFi component is used,
-                    # it will handle disabling DHCP server when AP is not configured.
-                    # Default to false (disabled) when WiFi is not used.
-                    cv.OnlyWithout(
-                        CONF_ENABLE_LWIP_DHCP_SERVER, "wifi", default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_MDNS_QUERIES, default=False
-                    ): cv.boolean,
-                    cv.Optional(
-                        CONF_ENABLE_LWIP_BRIDGE_INTERFACE, default=False
-                    ): cv.boolean,
+                    cv.Optional(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES): cv.boolean,
                 }
             ),
             cv.Optional(CONF_COMPONENTS, default=[]): cv.ensure_list(
@@ -680,7 +641,7 @@ async def to_code(config):
     conf = config[CONF_FRAMEWORK]
     cg.add_platformio_option("platform", conf[CONF_PLATFORM_VERSION])
 
-    if conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
+    if CONF_ADVANCED in conf and conf[CONF_ADVANCED][CONF_IGNORE_EFUSE_CUSTOM_MAC]:
         cg.add_define("USE_ESP32_IGNORE_EFUSE_CUSTOM_MAC")
 
     add_extra_script(
@@ -711,6 +672,8 @@ async def to_code(config):
         add_idf_sdkconfig_option(
             "CONFIG_PARTITION_TABLE_CUSTOM_FILENAME", "partitions.csv"
         )
+        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
+        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_SIZE", True)
 
         # Increase freertos tick speed from 100Hz to 1kHz so that delay() resolution is 1ms
         add_idf_sdkconfig_option("CONFIG_FREERTOS_HZ", 1000)
@@ -724,41 +687,16 @@ async def to_code(config):
         # Set default CPU frequency
         add_idf_sdkconfig_option(f"CONFIG_ESP_DEFAULT_CPU_FREQ_MHZ_{freq}", True)
 
-        # Apply LWIP optimization settings
-        advanced = conf[CONF_ADVANCED]
-        # DHCP server: only disable if explicitly set to false
-        # WiFi component handles its own optimization when AP mode is not used
-        if (
-            CONF_ENABLE_LWIP_DHCP_SERVER in advanced
-            and not advanced[CONF_ENABLE_LWIP_DHCP_SERVER]
-        ):
-            add_idf_sdkconfig_option("CONFIG_LWIP_DHCPS", False)
-        if not advanced.get(CONF_ENABLE_LWIP_MDNS_QUERIES, False):
-            add_idf_sdkconfig_option("CONFIG_LWIP_DNS_SUPPORT_MDNS_QUERIES", False)
-        if not advanced.get(CONF_ENABLE_LWIP_BRIDGE_INTERFACE, False):
-            add_idf_sdkconfig_option("CONFIG_LWIP_BRIDGEIF_MAX_PORTS", 0)
-
         cg.add_platformio_option("board_build.partitions", "partitions.csv")
         if CONF_PARTITIONS in config:
             add_extra_build_file(
                 "partitions.csv", CORE.relative_config_path(config[CONF_PARTITIONS])
             )
 
-        if assertion_level := advanced.get(CONF_ASSERTION_LEVEL):
-            for key, flag in ASSERTION_LEVELS.items():
-                add_idf_sdkconfig_option(flag, assertion_level == key)
+        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
+            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
 
-        add_idf_sdkconfig_option("CONFIG_COMPILER_OPTIMIZATION_DEFAULT", False)
-        compiler_optimization = advanced.get(CONF_COMPILER_OPTIMIZATION)
-        for key, flag in COMPILER_OPTIMIZATIONS.items():
-            add_idf_sdkconfig_option(flag, compiler_optimization == key)
-
-        add_idf_sdkconfig_option(
-            "CONFIG_LWIP_ESP_LWIP_ASSERT",
-            conf[CONF_ADVANCED][CONF_ENABLE_LWIP_ASSERT],
-        )
-
-        if advanced.get(CONF_IGNORE_EFUSE_MAC_CRC):
+        if conf[CONF_ADVANCED].get(CONF_IGNORE_EFUSE_MAC_CRC):
             add_idf_sdkconfig_option("CONFIG_ESP_MAC_IGNORE_MAC_CRC_ERROR", True)
             if (framework_ver.major, framework_ver.minor) >= (4, 4):
                 add_idf_sdkconfig_option(
@@ -768,7 +706,7 @@ async def to_code(config):
                 add_idf_sdkconfig_option(
                     "CONFIG_ESP32_PHY_CALIBRATION_AND_DATA_STORAGE", False
                 )
-        if advanced.get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
+        if conf[CONF_ADVANCED].get(CONF_ENABLE_IDF_EXPERIMENTAL_FEATURES):
             _LOGGER.warning(
                 "Using experimental features in ESP-IDF may result in unexpected failures."
             )
@@ -781,9 +719,6 @@ async def to_code(config):
             ),
         )
 
-        for name, value in conf[CONF_SDKCONFIG_OPTIONS].items():
-            add_idf_sdkconfig_option(name, RawSdkconfigValue(value))
-
         for component in conf[CONF_COMPONENTS]:
             source = component[CONF_SOURCE]
             if source[CONF_TYPE] == TYPE_GIT:

esphome/components/esp32/preferences.cpp

@@ -1,8 +1,8 @@
 #ifdef USE_ESP32
 
+#include "esphome/core/preferences.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
-#include "esphome/core/preferences.h"
 #include <nvs_flash.h>
 #include <cstring>
 #include <cinttypes>

esphome/components/esp32_ble/__init__.py

@@ -1,4 +1,3 @@
-from enum import Enum
 import re
 
 from esphome import automation
@@ -13,110 +12,9 @@ import esphome.final_validate as fv
 DEPENDENCIES = ["esp32"]
 CODEOWNERS = ["@jesserockz", "@Rapsssito"]
 
-
-class BTLoggers(Enum):
-    """Bluetooth logger categories available in ESP-IDF.
-
-    Each logger controls debug output for a specific Bluetooth subsystem.
-    The value is the ESP-IDF sdkconfig option name for controlling the log level.
-    """
-
-    # Core Stack Layers
-    HCI = "CONFIG_BT_LOG_HCI_TRACE_LEVEL"
-    """Host Controller Interface - Low-level interface between host and controller"""
-
-    BTM = "CONFIG_BT_LOG_BTM_TRACE_LEVEL"
-    """Bluetooth Manager - Core device control, connections, and security"""
-
-    L2CAP = "CONFIG_BT_LOG_L2CAP_TRACE_LEVEL"
-    """Logical Link Control and Adaptation Protocol - Connection multiplexing"""
-
-    RFCOMM = "CONFIG_BT_LOG_RFCOMM_TRACE_LEVEL"
-    """Serial port emulation over Bluetooth (Classic only)"""
-
-    SDP = "CONFIG_BT_LOG_SDP_TRACE_LEVEL"
-    """Service Discovery Protocol - Service discovery (Classic only)"""
-
-    GAP = "CONFIG_BT_LOG_GAP_TRACE_LEVEL"
-    """Generic Access Profile - Device discovery and connections"""
-
-    # Network Protocols
-    BNEP = "CONFIG_BT_LOG_BNEP_TRACE_LEVEL"
-    """Bluetooth Network Encapsulation Protocol - IP over Bluetooth"""
-
-    PAN = "CONFIG_BT_LOG_PAN_TRACE_LEVEL"
-    """Personal Area Networking - Ethernet over Bluetooth"""
-
-    # Audio/Video Profiles (Classic Bluetooth)
-    A2D = "CONFIG_BT_LOG_A2D_TRACE_LEVEL"
-    """Advanced Audio Distribution - A2DP audio streaming"""
-
-    AVDT = "CONFIG_BT_LOG_AVDT_TRACE_LEVEL"
-    """Audio/Video Distribution Transport - A2DP transport protocol"""
-
-    AVCT = "CONFIG_BT_LOG_AVCT_TRACE_LEVEL"
-    """Audio/Video Control Transport - AVRCP transport protocol"""
-
-    AVRC = "CONFIG_BT_LOG_AVRC_TRACE_LEVEL"
-    """Audio/Video Remote Control - Media playback control"""
-
-    # Security
-    SMP = "CONFIG_BT_LOG_SMP_TRACE_LEVEL"
-    """Security Manager Protocol - BLE pairing and encryption"""
-
-    # Application Layer
-    BTIF = "CONFIG_BT_LOG_BTIF_TRACE_LEVEL"
-    """Bluetooth Interface - Application interface layer"""
-
-    BTC = "CONFIG_BT_LOG_BTC_TRACE_LEVEL"
-    """Bluetooth Common - Task handling and coordination"""
-
-    # BLE Specific
-    BLE_SCAN = "CONFIG_BT_LOG_BLE_SCAN_TRACE_LEVEL"
-    """BLE scanning operations"""
-
-    GATT = "CONFIG_BT_LOG_GATT_TRACE_LEVEL"
-    """Generic Attribute Profile - BLE data exchange protocol"""
-
-    # Other Profiles
-    MCA = "CONFIG_BT_LOG_MCA_TRACE_LEVEL"
-    """Multi-Channel Adaptation - Health device profile"""
-
-    HID = "CONFIG_BT_LOG_HID_TRACE_LEVEL"
-    """Human Interface Device - Keyboards, mice, controllers"""
-
-    APPL = "CONFIG_BT_LOG_APPL_TRACE_LEVEL"
-    """Application layer logging"""
-
-    OSI = "CONFIG_BT_LOG_OSI_TRACE_LEVEL"
-    """OS abstraction layer - Threading, memory, timers"""
-
-    BLUFI = "CONFIG_BT_LOG_BLUFI_TRACE_LEVEL"
-    """ESP32 WiFi provisioning over Bluetooth"""
-
-
-# Set to track which loggers are needed by components
-_required_loggers: set[BTLoggers] = set()
-
-
-def register_bt_logger(*loggers: BTLoggers) -> None:
-    """Register Bluetooth logger categories that a component needs.
-
-    Args:
-        *loggers: One or more BTLoggers enum members
-    """
-    for logger in loggers:
-        if not isinstance(logger, BTLoggers):
-            raise TypeError(
-                f"Logger must be a BTLoggers enum member, got {type(logger)}"
-            )
-        _required_loggers.add(logger)
-
-
 CONF_BLE_ID = "ble_id"
 CONF_IO_CAPABILITY = "io_capability"
 CONF_ADVERTISING_CYCLE_TIME = "advertising_cycle_time"
-CONF_DISABLE_BT_LOGS = "disable_bt_logs"
 
 NO_BLUETOOTH_VARIANTS = [const.VARIANT_ESP32S2]
 
@@ -164,9 +62,6 @@ CONFIG_SCHEMA = cv.Schema(
         cv.Optional(
             CONF_ADVERTISING_CYCLE_TIME, default="10s"
         ): cv.positive_time_period_milliseconds,
-        cv.SplitDefault(CONF_DISABLE_BT_LOGS, esp32_idf=True): cv.All(
-            cv.only_with_esp_idf, cv.boolean
-        ),
     }
 ).extend(cv.COMPONENT_SCHEMA)
 
@@ -245,16 +140,6 @@ async def to_code(config):
         add_idf_sdkconfig_option("CONFIG_BT_ENABLED", True)
         add_idf_sdkconfig_option("CONFIG_BT_BLE_42_FEATURES_SUPPORTED", True)
 
-        # Register the core BLE loggers that are always needed
-        register_bt_logger(BTLoggers.GAP, BTLoggers.BTM, BTLoggers.HCI)
-
-        # Apply logger settings if log disabling is enabled
-        if config.get(CONF_DISABLE_BT_LOGS, False):
-            # Disable all Bluetooth loggers that are not required
-            for logger in BTLoggers:
-                if logger not in _required_loggers:
-                    add_idf_sdkconfig_option(f"{logger.value}_NONE", True)
-
     cg.add_define("USE_ESP32_BLE")
 
 

esphome/components/esp32_ble/ble.cpp

@@ -408,12 +408,10 @@ void ESP32BLE::dump_config() {
         io_capability_s = "invalid";
         break;
     }
-    ESP_LOGCONFIG(TAG,
-                  "ESP32 BLE:\n"
-                  "  MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n"
-                  "  IO Capability: %s",
-                  mac_address[0], mac_address[1], mac_address[2], mac_address[3], mac_address[4], mac_address[5],
-                  io_capability_s);
+    ESP_LOGCONFIG(TAG, "ESP32 BLE:");
+    ESP_LOGCONFIG(TAG, "  MAC address: %02X:%02X:%02X:%02X:%02X:%02X", mac_address[0], mac_address[1], mac_address[2],
+                  mac_address[3], mac_address[4], mac_address[5]);
+    ESP_LOGCONFIG(TAG, "  IO Capability: %s", io_capability_s);
   } else {
     ESP_LOGCONFIG(TAG, "ESP32 BLE: bluetooth stack is not enabled");
   }

esphome/components/esp32_ble/ble_uuid.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
+#include "esphome/core/hal.h"
 
 #ifdef USE_ESP32
 

esphome/components/esp32_ble_client/ble_client_base.cpp

@@ -45,10 +45,8 @@ void BLEClientBase::loop() {
 float BLEClientBase::get_setup_priority() const { return setup_priority::AFTER_BLUETOOTH; }
 
 void BLEClientBase::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "  Address: %s\n"
-                "  Auto-Connect: %s",
-                this->address_str().c_str(), TRUEFALSE(this->auto_connect_));
+  ESP_LOGCONFIG(TAG, "  Address: %s", this->address_str().c_str());
+  ESP_LOGCONFIG(TAG, "  Auto-Connect: %s", TRUEFALSE(this->auto_connect_));
   std::string state_name;
   switch (this->state()) {
     case espbt::ClientState::INIT:

esphome/components/esp32_ble_server/__init__.py

@@ -4,7 +4,7 @@ from esphome import automation
 import esphome.codegen as cg
 from esphome.components import esp32_ble
 from esphome.components.esp32 import add_idf_sdkconfig_option
-from esphome.components.esp32_ble import BTLoggers, bt_uuid
+from esphome.components.esp32_ble import bt_uuid
 import esphome.config_validation as cv
 from esphome.config_validation import UNDEFINED
 from esphome.const import (
@@ -525,9 +525,6 @@ async def to_code_characteristic(service_var, char_conf):
 
 
 async def to_code(config):
-    # Register the loggers this component needs
-    esp32_ble.register_bt_logger(BTLoggers.GATT, BTLoggers.SMP)
-
     var = cg.new_Pvariable(config[CONF_ID])
 
     await cg.register_component(var, config)

esphome/components/esp32_ble_server/ble_characteristic.cpp

@@ -2,7 +2,6 @@
 #include "ble_server.h"
 #include "ble_service.h"
 
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
 #ifdef USE_ESP32

esphome/components/esp32_ble_server/ble_server.h

@@ -43,6 +43,7 @@ class BLEServer : public Component,
   float get_setup_priority() const override;
   bool can_proceed() override;
 
+  void teardown();
   bool is_running();
 
   void set_manufacturer_data(const std::vector<uint8_t> &data) {

esphome/components/esp32_ble_tracker/__init__.py

@@ -9,7 +9,6 @@ import esphome.codegen as cg
 from esphome.components import esp32_ble
 from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.components.esp32_ble import (
-    BTLoggers,
     bt_uuid,
     bt_uuid16_format,
     bt_uuid32_format,
@@ -260,9 +259,6 @@ ESP_BLE_DEVICE_SCHEMA = cv.Schema(
 
 
 async def to_code(config):
-    # Register the loggers this component needs
-    esp32_ble.register_bt_logger(BTLoggers.BLE_SCAN)
-
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -731,14 +731,11 @@ uint64_t ESPBTDevice::address_uint64() const { return esp32_ble::ble_addr_to_uin
 
 void ESP32BLETracker::dump_config() {
   ESP_LOGCONFIG(TAG, "BLE Tracker:");
-  ESP_LOGCONFIG(TAG,
-                "  Scan Duration: %" PRIu32 " s\n"
-                "  Scan Interval: %.1f ms\n"
-                "  Scan Window: %.1f ms\n"
-                "  Scan Type: %s\n"
-                "  Continuous Scanning: %s",
-                this->scan_duration_, this->scan_interval_ * 0.625f, this->scan_window_ * 0.625f,
-                this->scan_active_ ? "ACTIVE" : "PASSIVE", YESNO(this->scan_continuous_));
+  ESP_LOGCONFIG(TAG, "  Scan Duration: %" PRIu32 " s", this->scan_duration_);
+  ESP_LOGCONFIG(TAG, "  Scan Interval: %.1f ms", this->scan_interval_ * 0.625f);
+  ESP_LOGCONFIG(TAG, "  Scan Window: %.1f ms", this->scan_window_ * 0.625f);
+  ESP_LOGCONFIG(TAG, "  Scan Type: %s", this->scan_active_ ? "ACTIVE" : "PASSIVE");
+  ESP_LOGCONFIG(TAG, "  Continuous Scanning: %s", YESNO(this->scan_continuous_));
   switch (this->scanner_state_) {
     case ScannerState::IDLE:
       ESP_LOGCONFIG(TAG, "  Scanner State: IDLE");

esphome/components/esp32_camera/esp32_camera.cpp

@@ -46,20 +46,17 @@ void ESP32Camera::setup() {
 
 void ESP32Camera::dump_config() {
   auto conf = this->config_;
-  ESP_LOGCONFIG(TAG,
-                "ESP32 Camera:\n"
-                "  Name: %s\n"
-                "  Internal: %s\n"
-                "  Data Pins: D0:%d D1:%d D2:%d D3:%d D4:%d D5:%d D6:%d D7:%d\n"
-                "  VSYNC Pin: %d\n"
-                "  HREF Pin: %d\n"
-                "  Pixel Clock Pin: %d\n"
-                "  External Clock: Pin:%d Frequency:%u\n"
-                "  I2C Pins: SDA:%d SCL:%d\n"
-                "  Reset Pin: %d",
-                this->name_.c_str(), YESNO(this->internal_), conf.pin_d0, conf.pin_d1, conf.pin_d2, conf.pin_d3,
-                conf.pin_d4, conf.pin_d5, conf.pin_d6, conf.pin_d7, conf.pin_vsync, conf.pin_href, conf.pin_pclk,
-                conf.pin_xclk, conf.xclk_freq_hz, conf.pin_sccb_sda, conf.pin_sccb_scl, conf.pin_reset);
+  ESP_LOGCONFIG(TAG, "ESP32 Camera:");
+  ESP_LOGCONFIG(TAG, "  Name: %s", this->name_.c_str());
+  ESP_LOGCONFIG(TAG, "  Internal: %s", YESNO(this->internal_));
+  ESP_LOGCONFIG(TAG, "  Data Pins: D0:%d D1:%d D2:%d D3:%d D4:%d D5:%d D6:%d D7:%d", conf.pin_d0, conf.pin_d1,
+                conf.pin_d2, conf.pin_d3, conf.pin_d4, conf.pin_d5, conf.pin_d6, conf.pin_d7);
+  ESP_LOGCONFIG(TAG, "  VSYNC Pin: %d", conf.pin_vsync);
+  ESP_LOGCONFIG(TAG, "  HREF Pin: %d", conf.pin_href);
+  ESP_LOGCONFIG(TAG, "  Pixel Clock Pin: %d", conf.pin_pclk);
+  ESP_LOGCONFIG(TAG, "  External Clock: Pin:%d Frequency:%u", conf.pin_xclk, conf.xclk_freq_hz);
+  ESP_LOGCONFIG(TAG, "  I2C Pins: SDA:%d SCL:%d", conf.pin_sccb_sda, conf.pin_sccb_scl);
+  ESP_LOGCONFIG(TAG, "  Reset Pin: %d", conf.pin_reset);
   switch (this->config_.frame_size) {
     case FRAMESIZE_QQVGA:
       ESP_LOGCONFIG(TAG, "  Resolution: 160x120 (QQVGA)");
@@ -126,29 +123,24 @@ void ESP32Camera::dump_config() {
 
   sensor_t *s = esp_camera_sensor_get();
   auto st = s->status;
-  ESP_LOGCONFIG(TAG,
-                "  JPEG Quality: %u\n"
-                "  Framebuffer Count: %u\n"
-                "  Contrast: %d\n"
-                "  Brightness: %d\n"
-                "  Saturation: %d\n"
-                "  Vertical Flip: %s\n"
-                "  Horizontal Mirror: %s\n"
-                "  Special Effect: %u\n"
-                "  White Balance Mode: %u",
-                st.quality, conf.fb_count, st.contrast, st.brightness, st.saturation, ONOFF(st.vflip),
-                ONOFF(st.hmirror), st.special_effect, st.wb_mode);
+  ESP_LOGCONFIG(TAG, "  JPEG Quality: %u", st.quality);
+  ESP_LOGCONFIG(TAG, "  Framebuffer Count: %u", conf.fb_count);
+  ESP_LOGCONFIG(TAG, "  Contrast: %d", st.contrast);
+  ESP_LOGCONFIG(TAG, "  Brightness: %d", st.brightness);
+  ESP_LOGCONFIG(TAG, "  Saturation: %d", st.saturation);
+  ESP_LOGCONFIG(TAG, "  Vertical Flip: %s", ONOFF(st.vflip));
+  ESP_LOGCONFIG(TAG, "  Horizontal Mirror: %s", ONOFF(st.hmirror));
+  ESP_LOGCONFIG(TAG, "  Special Effect: %u", st.special_effect);
+  ESP_LOGCONFIG(TAG, "  White Balance Mode: %u", st.wb_mode);
   // ESP_LOGCONFIG(TAG, "  Auto White Balance: %u", st.awb);
   // ESP_LOGCONFIG(TAG, "  Auto White Balance Gain: %u", st.awb_gain);
-  ESP_LOGCONFIG(TAG,
-                "  Auto Exposure Control: %u\n"
-                "  Auto Exposure Control 2: %u\n"
-                "  Auto Exposure Level: %d\n"
-                "  Auto Exposure Value: %u\n"
-                "  AGC: %u\n"
-                "  AGC Gain: %u\n"
-                "  Gain Ceiling: %u",
-                st.aec, st.aec2, st.ae_level, st.aec_value, st.agc, st.agc_gain, st.gainceiling);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Control: %u", st.aec);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Control 2: %u", st.aec2);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Level: %d", st.ae_level);
+  ESP_LOGCONFIG(TAG, "  Auto Exposure Value: %u", st.aec_value);
+  ESP_LOGCONFIG(TAG, "  AGC: %u", st.agc);
+  ESP_LOGCONFIG(TAG, "  AGC Gain: %u", st.agc_gain);
+  ESP_LOGCONFIG(TAG, "  Gain Ceiling: %u", st.gainceiling);
   // ESP_LOGCONFIG(TAG, "  BPC: %u", st.bpc);
   // ESP_LOGCONFIG(TAG, "  WPC: %u", st.wpc);
   // ESP_LOGCONFIG(TAG, "  RAW_GMA: %u", st.raw_gma);

esphome/components/esp32_camera_web_server/camera_web_server.cpp

@@ -85,10 +85,8 @@ void CameraWebServer::on_shutdown() {
 }
 
 void CameraWebServer::dump_config() {
-  ESP_LOGCONFIG(TAG,
-                "ESP32 Camera Web Server:\n"
-                "  Port: %d",
-                this->port_);
+  ESP_LOGCONFIG(TAG, "ESP32 Camera Web Server:");
+  ESP_LOGCONFIG(TAG, "  Port: %d", this->port_);
   if (this->mode_ == STREAM) {
     ESP_LOGCONFIG(TAG, "  Mode: stream");
   } else {

esphome/components/esp32_dac/esp32_dac.cpp

@@ -1,6 +1,6 @@
 #include "esp32_dac.h"
-#include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
+#include "esphome/core/helpers.h"
 
 #ifdef USE_ESP32