Merge branch 'fix_bytes_encoding' into integration

This reverts commit c96ffefa42.

CODEOWNERS

@@ -327,6 +327,7 @@ esphome/components/opentherm/* @olegtarasov
 esphome/components/openthread/* @mrene
 esphome/components/opt3001/* @ccutrer
 esphome/components/ota/* @esphome/core
+esphome/components/ota_base/* @esphome/core
 esphome/components/output/* @esphome/core
 esphome/components/packet_transport/* @clydebarrow
 esphome/components/pca6416a/* @Mat931

esphome/components/api/api_pb2.cpp

@@ -3493,7 +3493,7 @@ bool SubscribeLogsResponse::decode_length(uint32_t field_id, ProtoLengthDelimite
 }
 void SubscribeLogsResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_enum<enums::LogLevel>(1, this->level);
-  buffer.encode_string(3, this->message);
+  buffer.encode_bytes(3, reinterpret_cast<const uint8_t *>(this->message.data()), this->message.size());
   buffer.encode_bool(4, this->send_failed);
 }
 void SubscribeLogsResponse::calculate_size(uint32_t &total_size) const {
@@ -3529,7 +3529,9 @@ bool NoiseEncryptionSetKeyRequest::decode_length(uint32_t field_id, ProtoLengthD
       return false;
   }
 }
-void NoiseEncryptionSetKeyRequest::encode(ProtoWriteBuffer buffer) const { buffer.encode_string(1, this->key); }
+void NoiseEncryptionSetKeyRequest::encode(ProtoWriteBuffer buffer) const {
+  buffer.encode_bytes(1, reinterpret_cast<const uint8_t *>(this->key.data()), this->key.size());
+}
 void NoiseEncryptionSetKeyRequest::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->key, false);
 }
@@ -4266,7 +4268,7 @@ bool CameraImageResponse::decode_32bit(uint32_t field_id, Proto32Bit value) {
 }
 void CameraImageResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_fixed32(1, this->key);
-  buffer.encode_string(2, this->data);
+  buffer.encode_bytes(2, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
   buffer.encode_bool(3, this->done);
 }
 void CameraImageResponse::calculate_size(uint32_t &total_size) const {
@@ -6784,7 +6786,7 @@ void BluetoothServiceData::encode(ProtoWriteBuffer buffer) const {
   for (auto &it : this->legacy_data) {
     buffer.encode_uint32(2, it, true);
   }
-  buffer.encode_string(3, this->data);
+  buffer.encode_bytes(3, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothServiceData::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_string_field(total_size, 1, this->uuid, false);
@@ -6858,7 +6860,7 @@ bool BluetoothLEAdvertisementResponse::decode_length(uint32_t field_id, ProtoLen
 }
 void BluetoothLEAdvertisementResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
-  buffer.encode_string(2, this->name);
+  buffer.encode_bytes(2, reinterpret_cast<const uint8_t *>(this->name.data()), this->name.size());
   buffer.encode_sint32(3, this->rssi);
   for (auto &it : this->service_uuids) {
     buffer.encode_string(4, it, true);
@@ -6959,7 +6961,7 @@ void BluetoothLERawAdvertisement::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_sint32(2, this->rssi);
   buffer.encode_uint32(3, this->address_type);
-  buffer.encode_string(4, this->data);
+  buffer.encode_bytes(4, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothLERawAdvertisement::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_uint64_field(total_size, 1, this->address, false);
@@ -7492,7 +7494,7 @@ bool BluetoothGATTReadResponse::decode_length(uint32_t field_id, ProtoLengthDeli
 void BluetoothGATTReadResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
-  buffer.encode_string(3, this->data);
+  buffer.encode_bytes(3, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothGATTReadResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_uint64_field(total_size, 1, this->address, false);
@@ -7551,7 +7553,7 @@ void BluetoothGATTWriteRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
   buffer.encode_bool(3, this->response);
-  buffer.encode_string(4, this->data);
+  buffer.encode_bytes(4, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothGATTWriteRequest::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_uint64_field(total_size, 1, this->address, false);
@@ -7648,7 +7650,7 @@ bool BluetoothGATTWriteDescriptorRequest::decode_length(uint32_t field_id, Proto
 void BluetoothGATTWriteDescriptorRequest::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
-  buffer.encode_string(3, this->data);
+  buffer.encode_bytes(3, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothGATTWriteDescriptorRequest::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_uint64_field(total_size, 1, this->address, false);
@@ -7750,7 +7752,7 @@ bool BluetoothGATTNotifyDataResponse::decode_length(uint32_t field_id, ProtoLeng
 void BluetoothGATTNotifyDataResponse::encode(ProtoWriteBuffer buffer) const {
   buffer.encode_uint64(1, this->address);
   buffer.encode_uint32(2, this->handle);
-  buffer.encode_string(3, this->data);
+  buffer.encode_bytes(3, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
 }
 void BluetoothGATTNotifyDataResponse::calculate_size(uint32_t &total_size) const {
   ProtoSize::add_uint64_field(total_size, 1, this->address, false);
@@ -8480,7 +8482,7 @@ bool VoiceAssistantAudio::decode_length(uint32_t field_id, ProtoLengthDelimited
   }
 }
 void VoiceAssistantAudio::encode(ProtoWriteBuffer buffer) const {
-  buffer.encode_string(1, this->data);
+  buffer.encode_bytes(1, reinterpret_cast<const uint8_t *>(this->data.data()), this->data.size());
   buffer.encode_bool(2, this->end);
 }
 void VoiceAssistantAudio::calculate_size(uint32_t &total_size) const {

esphome/components/esp32_ble_tracker/esp32_ble_tracker.cpp

@@ -18,7 +18,7 @@
 #include <cinttypes>
 
 #ifdef USE_OTA
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 #endif
 
 #ifdef USE_ESP32_BLE_SOFTWARE_COEXISTENCE
@@ -61,9 +61,9 @@ void ESP32BLETracker::setup() {
   global_esp32_ble_tracker = this;
 
 #ifdef USE_OTA
-  ota::get_global_ota_callback()->add_on_state_callback(
+  ota_base::get_global_ota_callback()->add_on_state_callback(
-      [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
+      [this](ota_base::OTAState state, float progress, uint8_t error, ota_base::OTAComponent *comp) {
-        if (state == ota::OTA_STARTED) {
+        if (state == ota_base::OTA_STARTED) {
           this->stop_scan();
           for (auto *client : this->clients_) {
             client->disconnect();

esphome/components/esphome/ota/__init__.py

@@ -1,7 +1,8 @@
 import logging
 
 import esphome.codegen as cg
-from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
+from esphome.components.ota import BASE_OTA_SCHEMA, ota_to_code
+from esphome.components.ota_base import OTAComponent
 from esphome.config_helpers import merge_config
 import esphome.config_validation as cv
 from esphome.const import (

esphome/components/esphome/ota/ota_esphome.cpp

@@ -2,12 +2,12 @@
 #ifdef USE_OTA
 #include "esphome/components/md5/md5.h"
 #include "esphome/components/network/util.h"
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"  // For OTAComponent and callbacks
-#include "esphome/components/ota/ota_backend_arduino_esp32.h"
+#include "esphome/components/ota_base/ota_backend_arduino_esp32.h"
-#include "esphome/components/ota/ota_backend_arduino_esp8266.h"
+#include "esphome/components/ota_base/ota_backend_arduino_esp8266.h"
-#include "esphome/components/ota/ota_backend_arduino_libretiny.h"
+#include "esphome/components/ota_base/ota_backend_arduino_libretiny.h"
-#include "esphome/components/ota/ota_backend_arduino_rp2040.h"
+#include "esphome/components/ota_base/ota_backend_arduino_rp2040.h"
-#include "esphome/components/ota/ota_backend_esp_idf.h"
+#include "esphome/components/ota_base/ota_backend_esp_idf.h"
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/log.h"
@@ -23,7 +23,7 @@ static constexpr u_int16_t OTA_BLOCK_SIZE = 8192;
 
 void ESPHomeOTAComponent::setup() {
 #ifdef USE_OTA_STATE_CALLBACK
-  ota::register_ota_platform(this);
+  ota_base::register_ota_platform(this);
 #endif
 
   this->server_ = socket::socket_ip_loop_monitored(SOCK_STREAM, 0);  // monitored for incoming connections
@@ -94,7 +94,7 @@ void ESPHomeOTAComponent::loop() {
 static const uint8_t FEATURE_SUPPORTS_COMPRESSION = 0x01;
 
 void ESPHomeOTAComponent::handle_() {
-  ota::OTAResponseTypes error_code = ota::OTA_RESPONSE_ERROR_UNKNOWN;
+  ota_base::OTAResponseTypes error_code = ota_base::OTA_RESPONSE_ERROR_UNKNOWN;
   bool update_started = false;
   size_t total = 0;
   uint32_t last_progress = 0;
@@ -102,7 +102,7 @@ void ESPHomeOTAComponent::handle_() {
   char *sbuf = reinterpret_cast<char *>(buf);
   size_t ota_size;
   uint8_t ota_features;
-  std::unique_ptr<ota::OTABackend> backend;
+  std::unique_ptr<ota_base::OTABackend> backend;
   (void) ota_features;
 #if USE_OTA_VERSION == 2
   size_t size_acknowledged = 0;
@@ -129,7 +129,7 @@ void ESPHomeOTAComponent::handle_() {
   ESP_LOGD(TAG, "Starting update from %s", this->client_->getpeername().c_str());
   this->status_set_warning();
 #ifdef USE_OTA_STATE_CALLBACK
-  this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
+  this->state_callback_.call(ota_base::OTA_STARTED, 0.0f, 0);
 #endif
 
   if (!this->readall_(buf, 5)) {
@@ -140,16 +140,16 @@ void ESPHomeOTAComponent::handle_() {
   if (buf[0] != 0x6C || buf[1] != 0x26 || buf[2] != 0xF7 || buf[3] != 0x5C || buf[4] != 0x45) {
     ESP_LOGW(TAG, "Magic bytes do not match! 0x%02X-0x%02X-0x%02X-0x%02X-0x%02X", buf[0], buf[1], buf[2], buf[3],
              buf[4]);
-    error_code = ota::OTA_RESPONSE_ERROR_MAGIC;
+    error_code = ota_base::OTA_RESPONSE_ERROR_MAGIC;
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
 
   // Send OK and version - 2 bytes
-  buf[0] = ota::OTA_RESPONSE_OK;
+  buf[0] = ota_base::OTA_RESPONSE_OK;
   buf[1] = USE_OTA_VERSION;
   this->writeall_(buf, 2);
 
-  backend = ota::make_ota_backend();
+  backend = ota_base::make_ota_backend();
 
   // Read features - 1 byte
   if (!this->readall_(buf, 1)) {
@@ -160,16 +160,16 @@ void ESPHomeOTAComponent::handle_() {
   ESP_LOGV(TAG, "Features: 0x%02X", ota_features);
 
   // Acknowledge header - 1 byte
-  buf[0] = ota::OTA_RESPONSE_HEADER_OK;
+  buf[0] = ota_base::OTA_RESPONSE_HEADER_OK;
   if ((ota_features & FEATURE_SUPPORTS_COMPRESSION) != 0 && backend->supports_compression()) {
-    buf[0] = ota::OTA_RESPONSE_SUPPORTS_COMPRESSION;
+    buf[0] = ota_base::OTA_RESPONSE_SUPPORTS_COMPRESSION;
   }
 
   this->writeall_(buf, 1);
 
 #ifdef USE_OTA_PASSWORD
   if (!this->password_.empty()) {
-    buf[0] = ota::OTA_RESPONSE_REQUEST_AUTH;
+    buf[0] = ota_base::OTA_RESPONSE_REQUEST_AUTH;
     this->writeall_(buf, 1);
     md5::MD5Digest md5{};
     md5.init();
@@ -220,14 +220,14 @@ void ESPHomeOTAComponent::handle_() {
 
     if (!matches) {
       ESP_LOGW(TAG, "Auth failed! Passwords do not match");
-      error_code = ota::OTA_RESPONSE_ERROR_AUTH_INVALID;
+      error_code = ota_base::OTA_RESPONSE_ERROR_AUTH_INVALID;
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
   }
 #endif  // USE_OTA_PASSWORD
 
   // Acknowledge auth OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_AUTH_OK;
+  buf[0] = ota_base::OTA_RESPONSE_AUTH_OK;
   this->writeall_(buf, 1);
 
   // Read size, 4 bytes MSB first
@@ -243,12 +243,12 @@ void ESPHomeOTAComponent::handle_() {
   ESP_LOGV(TAG, "Size is %u bytes", ota_size);
 
   error_code = backend->begin(ota_size);
-  if (error_code != ota::OTA_RESPONSE_OK)
+  if (error_code != ota_base::OTA_RESPONSE_OK)
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   update_started = true;
 
   // Acknowledge prepare OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_PREPARE_OK;
+  buf[0] = ota_base::OTA_RESPONSE_UPDATE_PREPARE_OK;
   this->writeall_(buf, 1);
 
   // Read binary MD5, 32 bytes
@@ -261,7 +261,7 @@ void ESPHomeOTAComponent::handle_() {
   backend->set_update_md5(sbuf);
 
   // Acknowledge MD5 OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_BIN_MD5_OK;
+  buf[0] = ota_base::OTA_RESPONSE_BIN_MD5_OK;
   this->writeall_(buf, 1);
 
   while (total < ota_size) {
@@ -285,14 +285,14 @@ void ESPHomeOTAComponent::handle_() {
     }
 
     error_code = backend->write(buf, read);
-    if (error_code != ota::OTA_RESPONSE_OK) {
+    if (error_code != ota_base::OTA_RESPONSE_OK) {
       ESP_LOGW(TAG, "Error writing binary data to flash!, error_code: %d", error_code);
       goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
     }
     total += read;
 #if USE_OTA_VERSION == 2
     while (size_acknowledged + OTA_BLOCK_SIZE <= total || (total == ota_size && size_acknowledged < ota_size)) {
-      buf[0] = ota::OTA_RESPONSE_CHUNK_OK;
+      buf[0] = ota_base::OTA_RESPONSE_CHUNK_OK;
       this->writeall_(buf, 1);
       size_acknowledged += OTA_BLOCK_SIZE;
     }
@@ -304,7 +304,7 @@ void ESPHomeOTAComponent::handle_() {
       float percentage = (total * 100.0f) / ota_size;
       ESP_LOGD(TAG, "Progress: %0.1f%%", percentage);
 #ifdef USE_OTA_STATE_CALLBACK
-      this->state_callback_.call(ota::OTA_IN_PROGRESS, percentage, 0);
+      this->state_callback_.call(ota_base::OTA_IN_PROGRESS, percentage, 0);
 #endif
       // feed watchdog and give other tasks a chance to run
       App.feed_wdt();
@@ -313,21 +313,21 @@ void ESPHomeOTAComponent::handle_() {
   }
 
   // Acknowledge receive OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_RECEIVE_OK;
+  buf[0] = ota_base::OTA_RESPONSE_RECEIVE_OK;
   this->writeall_(buf, 1);
 
   error_code = backend->end();
-  if (error_code != ota::OTA_RESPONSE_OK) {
+  if (error_code != ota_base::OTA_RESPONSE_OK) {
     ESP_LOGW(TAG, "Error ending update! error_code: %d", error_code);
     goto error;  // NOLINT(cppcoreguidelines-avoid-goto)
   }
 
   // Acknowledge Update end OK - 1 byte
-  buf[0] = ota::OTA_RESPONSE_UPDATE_END_OK;
+  buf[0] = ota_base::OTA_RESPONSE_UPDATE_END_OK;
   this->writeall_(buf, 1);
 
   // Read ACK
-  if (!this->readall_(buf, 1) || buf[0] != ota::OTA_RESPONSE_OK) {
+  if (!this->readall_(buf, 1) || buf[0] != ota_base::OTA_RESPONSE_OK) {
     ESP_LOGW(TAG, "Reading back acknowledgement failed");
     // do not go to error, this is not fatal
   }
@@ -338,7 +338,7 @@ void ESPHomeOTAComponent::handle_() {
   ESP_LOGI(TAG, "Update complete");
   this->status_clear_warning();
 #ifdef USE_OTA_STATE_CALLBACK
-  this->state_callback_.call(ota::OTA_COMPLETED, 100.0f, 0);
+  this->state_callback_.call(ota_base::OTA_COMPLETED, 100.0f, 0);
 #endif
   delay(100);  // NOLINT
   App.safe_reboot();
@@ -355,7 +355,7 @@ error:
 
   this->status_momentary_error("onerror", 5000);
 #ifdef USE_OTA_STATE_CALLBACK
-  this->state_callback_.call(ota::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+  this->state_callback_.call(ota_base::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
 #endif
 }
 

esphome/components/esphome/ota/ota_esphome.h

@@ -4,13 +4,13 @@
 #ifdef USE_OTA
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 #include "esphome/components/socket/socket.h"
 
 namespace esphome {
 
 /// ESPHomeOTAComponent provides a simple way to integrate Over-the-Air updates into your app using ArduinoOTA.
-class ESPHomeOTAComponent : public ota::OTAComponent {
+class ESPHomeOTAComponent : public ota_base::OTAComponent {
  public:
 #ifdef USE_OTA_PASSWORD
   void set_auth_password(const std::string &password) { password_ = password; }

esphome/components/http_request/ota/__init__.py

@@ -1,6 +1,6 @@
 from esphome import automation
 import esphome.codegen as cg
-from esphome.components.ota import BASE_OTA_SCHEMA, OTAComponent, ota_to_code
+from esphome.components.ota import BASE_OTA_SCHEMA, ota_to_code
 import esphome.config_validation as cv
 from esphome.const import CONF_ID, CONF_PASSWORD, CONF_URL, CONF_USERNAME
 from esphome.core import coroutine_with_priority
@@ -15,6 +15,9 @@ DEPENDENCIES = ["network", "http_request"]
 CONF_MD5 = "md5"
 CONF_MD5_URL = "md5_url"
 
+ota_base_ns = cg.esphome_ns.namespace("ota_base")
+OTAComponent = ota_base_ns.class_("OTAComponent", cg.Component)
+
 OtaHttpRequestComponent = http_request_ns.class_(
     "OtaHttpRequestComponent", OTAComponent
 )

esphome/components/http_request/ota/ota_http_request.cpp

@@ -6,11 +6,11 @@
 
 #include "esphome/components/md5/md5.h"
 #include "esphome/components/watchdog/watchdog.h"
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
-#include "esphome/components/ota/ota_backend_arduino_esp32.h"
+#include "esphome/components/ota_base/ota_backend_arduino_esp32.h"
-#include "esphome/components/ota/ota_backend_arduino_esp8266.h"
+#include "esphome/components/ota_base/ota_backend_arduino_esp8266.h"
-#include "esphome/components/ota/ota_backend_arduino_rp2040.h"
+#include "esphome/components/ota_base/ota_backend_arduino_rp2040.h"
-#include "esphome/components/ota/ota_backend_esp_idf.h"
+#include "esphome/components/ota_base/ota_backend_esp_idf.h"
 
 namespace esphome {
 namespace http_request {
@@ -19,7 +19,7 @@ static const char *const TAG = "http_request.ota";
 
 void OtaHttpRequestComponent::setup() {
 #ifdef USE_OTA_STATE_CALLBACK
-  ota::register_ota_platform(this);
+  ota_base::register_ota_platform(this);
 #endif
 }
 
@@ -50,15 +50,15 @@ void OtaHttpRequestComponent::flash() {
 
   ESP_LOGI(TAG, "Starting update");
 #ifdef USE_OTA_STATE_CALLBACK
-  this->state_callback_.call(ota::OTA_STARTED, 0.0f, 0);
+  this->state_callback_.call(ota_base::OTA_STARTED, 0.0f, 0);
 #endif
 
   auto ota_status = this->do_ota_();
 
   switch (ota_status) {
-    case ota::OTA_RESPONSE_OK:
+    case ota_base::OTA_RESPONSE_OK:
 #ifdef USE_OTA_STATE_CALLBACK
-      this->state_callback_.call(ota::OTA_COMPLETED, 100.0f, ota_status);
+      this->state_callback_.call(ota_base::OTA_COMPLETED, 100.0f, ota_status);
 #endif
       delay(10);
       App.safe_reboot();
@@ -66,7 +66,7 @@ void OtaHttpRequestComponent::flash() {
 
     default:
 #ifdef USE_OTA_STATE_CALLBACK
-      this->state_callback_.call(ota::OTA_ERROR, 0.0f, ota_status);
+      this->state_callback_.call(ota_base::OTA_ERROR, 0.0f, ota_status);
 #endif
       this->md5_computed_.clear();  // will be reset at next attempt
       this->md5_expected_.clear();  // will be reset at next attempt
@@ -74,7 +74,7 @@ void OtaHttpRequestComponent::flash() {
   }
 }
 
-void OtaHttpRequestComponent::cleanup_(std::unique_ptr<ota::OTABackend> backend,
+void OtaHttpRequestComponent::cleanup_(std::unique_ptr<ota_base::OTABackend> backend,
                                        const std::shared_ptr<HttpContainer> &container) {
   if (this->update_started_) {
     ESP_LOGV(TAG, "Aborting OTA backend");
@@ -115,9 +115,9 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
   ESP_LOGV(TAG, "MD5Digest initialized");
 
   ESP_LOGV(TAG, "OTA backend begin");
-  auto backend = ota::make_ota_backend();
+  auto backend = ota_base::make_ota_backend();
   auto error_code = backend->begin(container->content_length);
-  if (error_code != ota::OTA_RESPONSE_OK) {
+  if (error_code != ota_base::OTA_RESPONSE_OK) {
     ESP_LOGW(TAG, "backend->begin error: %d", error_code);
     this->cleanup_(std::move(backend), container);
     return error_code;
@@ -144,7 +144,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
       // write bytes to OTA backend
       this->update_started_ = true;
       error_code = backend->write(buf, bufsize);
-      if (error_code != ota::OTA_RESPONSE_OK) {
+      if (error_code != ota_base::OTA_RESPONSE_OK) {
         // error code explanation available at
         // https://github.com/esphome/esphome/blob/dev/esphome/components/ota/ota_backend.h
         ESP_LOGE(TAG, "Error code (%02X) writing binary data to flash at offset %d and size %d", error_code,
@@ -160,7 +160,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
       float percentage = container->get_bytes_read() * 100.0f / container->content_length;
       ESP_LOGD(TAG, "Progress: %0.1f%%", percentage);
 #ifdef USE_OTA_STATE_CALLBACK
-      this->state_callback_.call(ota::OTA_IN_PROGRESS, percentage, 0);
+      this->state_callback_.call(ota_base::OTA_IN_PROGRESS, percentage, 0);
 #endif
     }
   }  // while
@@ -174,7 +174,7 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
   if (strncmp(this->md5_computed_.c_str(), this->md5_expected_.c_str(), MD5_SIZE) != 0) {
     ESP_LOGE(TAG, "MD5 computed: %s - Aborting due to MD5 mismatch", this->md5_computed_.c_str());
     this->cleanup_(std::move(backend), container);
-    return ota::OTA_RESPONSE_ERROR_MD5_MISMATCH;
+    return ota_base::OTA_RESPONSE_ERROR_MD5_MISMATCH;
   } else {
     backend->set_update_md5(md5_receive_str.get());
   }
@@ -187,14 +187,14 @@ uint8_t OtaHttpRequestComponent::do_ota_() {
   delay(100);  // NOLINT
 
   error_code = backend->end();
-  if (error_code != ota::OTA_RESPONSE_OK) {
+  if (error_code != ota_base::OTA_RESPONSE_OK) {
     ESP_LOGW(TAG, "Error ending update! error_code: %d", error_code);
     this->cleanup_(std::move(backend), container);
     return error_code;
   }
 
   ESP_LOGI(TAG, "Update complete");
-  return ota::OTA_RESPONSE_OK;
+  return ota_base::OTA_RESPONSE_OK;
 }
 
 std::string OtaHttpRequestComponent::get_url_with_auth_(const std::string &url) {

esphome/components/http_request/ota/ota_http_request.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 #include "esphome/core/component.h"
 #include "esphome/core/defines.h"
 #include "esphome/core/helpers.h"
@@ -22,7 +22,7 @@ enum OtaHttpRequestError : uint8_t {
   OTA_CONNECTION_ERROR = 0x12,
 };
 
-class OtaHttpRequestComponent : public ota::OTAComponent, public Parented<HttpRequestComponent> {
+class OtaHttpRequestComponent : public ota_base::OTAComponent, public Parented<HttpRequestComponent> {
  public:
   void setup() override;
   void dump_config() override;
@@ -40,7 +40,7 @@ class OtaHttpRequestComponent : public ota::OTAComponent, public Parented<HttpRe
   void flash();
 
  protected:
-  void cleanup_(std::unique_ptr<ota::OTABackend> backend, const std::shared_ptr<HttpContainer> &container);
+  void cleanup_(std::unique_ptr<ota_base::OTABackend> backend, const std::shared_ptr<HttpContainer> &container);
   uint8_t do_ota_();
   std::string get_url_with_auth_(const std::string &url);
   bool http_get_md5_();

esphome/components/http_request/update/http_request_update.cpp

@@ -5,6 +5,7 @@
 
 #include "esphome/components/json/json_util.h"
 #include "esphome/components/network/util.h"
+#include "esphome/components/ota_base/ota_backend.h"
 
 namespace esphome {
 namespace http_request {
@@ -21,13 +22,13 @@ static const char *const TAG = "http_request.update";
 static const size_t MAX_READ_SIZE = 256;
 
 void HttpRequestUpdate::setup() {
-  this->ota_parent_->add_on_state_callback([this](ota::OTAState state, float progress, uint8_t err) {
+  this->ota_parent_->add_on_state_callback([this](ota_base::OTAState state, float progress, uint8_t err) {
-    if (state == ota::OTAState::OTA_IN_PROGRESS) {
+    if (state == ota_base::OTAState::OTA_IN_PROGRESS) {
       this->state_ = update::UPDATE_STATE_INSTALLING;
       this->update_info_.has_progress = true;
       this->update_info_.progress = progress;
       this->publish_state();
-    } else if (state == ota::OTAState::OTA_ABORT || state == ota::OTAState::OTA_ERROR) {
+    } else if (state == ota_base::OTAState::OTA_ABORT || state == ota_base::OTAState::OTA_ERROR) {
       this->state_ = update::UPDATE_STATE_AVAILABLE;
       this->status_set_error("Failed to install firmware");
       this->publish_state();

esphome/components/micro_wake_word/micro_wake_word.cpp

@@ -9,7 +9,7 @@
 #include "esphome/components/audio/audio_transfer_buffer.h"
 
 #ifdef USE_OTA
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 #endif
 
 namespace esphome {
@@ -121,11 +121,11 @@ void MicroWakeWord::setup() {
   });
 
 #ifdef USE_OTA
-  ota::get_global_ota_callback()->add_on_state_callback(
+  ota_base::get_global_ota_callback()->add_on_state_callback(
-      [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
+      [this](ota_base::OTAState state, float progress, uint8_t error, ota_base::OTAComponent *comp) {
-        if (state == ota::OTA_STARTED) {
+        if (state == ota_base::OTA_STARTED) {
           this->suspend_task_();
-        } else if (state == ota::OTA_ERROR) {
+        } else if (state == ota_base::OTA_ERROR) {
           this->resume_task_();
         }
       });

esphome/components/ota/__init__.py

@@ -8,10 +8,12 @@ from esphome.const import (
     CONF_PLATFORM,
     CONF_TRIGGER_ID,
 )
-from esphome.core import CORE, coroutine_with_priority
+from esphome.core import coroutine_with_priority
+
+from ..ota_base import OTAState
 
 CODEOWNERS = ["@esphome/core"]
-AUTO_LOAD = ["md5", "safe_mode"]
+AUTO_LOAD = ["safe_mode", "ota_base"]
 
 IS_PLATFORM_COMPONENT = True
 
@@ -23,8 +25,6 @@ CONF_ON_STATE_CHANGE = "on_state_change"
 
 
 ota_ns = cg.esphome_ns.namespace("ota")
-OTAComponent = ota_ns.class_("OTAComponent", cg.Component)
-OTAState = ota_ns.enum("OTAState")
 OTAAbortTrigger = ota_ns.class_("OTAAbortTrigger", automation.Trigger.template())
 OTAEndTrigger = ota_ns.class_("OTAEndTrigger", automation.Trigger.template())
 OTAErrorTrigger = ota_ns.class_("OTAErrorTrigger", automation.Trigger.template())
@@ -84,12 +84,6 @@ BASE_OTA_SCHEMA = cv.Schema(
 async def to_code(config):
     cg.add_define("USE_OTA")
 
-    if CORE.is_esp32 and CORE.using_arduino:
-        cg.add_library("Update", None)
-
-    if CORE.is_rp2040 and CORE.using_arduino:
-        cg.add_library("Updater", None)
-
 
 async def ota_to_code(var, config):
     await cg.past_safe_mode()

esphome/components/ota/automation.h

@@ -1,12 +1,16 @@
 #pragma once
 #ifdef USE_OTA_STATE_CALLBACK
-#include "ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 
 #include "esphome/core/automation.h"
 
 namespace esphome {
 namespace ota {
 
+// Import types from ota_base for the automation triggers
+using ota_base::OTAComponent;
+using ota_base::OTAState;
+
 class OTAStateChangeTrigger : public Trigger<OTAState> {
  public:
   explicit OTAStateChangeTrigger(OTAComponent *parent) {
@@ -22,7 +26,7 @@ class OTAStartTrigger : public Trigger<> {
  public:
   explicit OTAStartTrigger(OTAComponent *parent) {
     parent->add_on_state_callback([this, parent](OTAState state, float progress, uint8_t error) {
-      if (state == OTA_STARTED && !parent->is_failed()) {
+      if (state == ota_base::OTA_STARTED && !parent->is_failed()) {
         trigger();
       }
     });
@@ -33,7 +37,7 @@ class OTAProgressTrigger : public Trigger<float> {
  public:
   explicit OTAProgressTrigger(OTAComponent *parent) {
     parent->add_on_state_callback([this, parent](OTAState state, float progress, uint8_t error) {
-      if (state == OTA_IN_PROGRESS && !parent->is_failed()) {
+      if (state == ota_base::OTA_IN_PROGRESS && !parent->is_failed()) {
         trigger(progress);
       }
     });
@@ -44,7 +48,7 @@ class OTAEndTrigger : public Trigger<> {
  public:
   explicit OTAEndTrigger(OTAComponent *parent) {
     parent->add_on_state_callback([this, parent](OTAState state, float progress, uint8_t error) {
-      if (state == OTA_COMPLETED && !parent->is_failed()) {
+      if (state == ota_base::OTA_COMPLETED && !parent->is_failed()) {
         trigger();
       }
     });
@@ -55,7 +59,7 @@ class OTAAbortTrigger : public Trigger<> {
  public:
   explicit OTAAbortTrigger(OTAComponent *parent) {
     parent->add_on_state_callback([this, parent](OTAState state, float progress, uint8_t error) {
-      if (state == OTA_ABORT && !parent->is_failed()) {
+      if (state == ota_base::OTA_ABORT && !parent->is_failed()) {
         trigger();
       }
     });
@@ -66,7 +70,7 @@ class OTAErrorTrigger : public Trigger<uint8_t> {
  public:
   explicit OTAErrorTrigger(OTAComponent *parent) {
     parent->add_on_state_callback([this, parent](OTAState state, float progress, uint8_t error) {
-      if (state == OTA_ERROR && !parent->is_failed()) {
+      if (state == ota_base::OTA_ERROR && !parent->is_failed()) {
         trigger(error);
       }
     });

esphome/components/ota_base/__init__.py

@@ -0,0 +1,23 @@
+import esphome.codegen as cg
+from esphome.core import CORE, coroutine_with_priority
+
+CODEOWNERS = ["@esphome/core"]
+AUTO_LOAD = ["md5"]
+
+ota_base_ns = cg.esphome_ns.namespace("ota_base")
+OTAComponent = ota_base_ns.class_("OTAComponent", cg.Component)
+OTAState = ota_base_ns.enum("OTAState")
+
+
+@coroutine_with_priority(52.0)
+async def to_code(config):
+    # Note: USE_OTA_STATE_CALLBACK is not defined here
+    # Components that need OTA callbacks (like esp32_ble_tracker, speaker, etc.)
+    # define USE_OTA_STATE_CALLBACK themselves in their own __init__.py files
+    # This ensures the callback functionality is only compiled when actually needed
+
+    if CORE.is_esp32 and CORE.using_arduino:
+        cg.add_library("Update", None)
+
+    if CORE.is_rp2040 and CORE.using_arduino:
+        cg.add_library("Updater", None)

esphome/components/ota_base/ota_backend.cpp

@@ -1,7 +1,9 @@
 #include "ota_backend.h"
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
+
+// The make_ota_backend() implementation is provided by each platform-specific backend
 
 #ifdef USE_OTA_STATE_CALLBACK
 OTAGlobalCallback *global_ota_callback{nullptr};  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
@@ -16,5 +18,5 @@ OTAGlobalCallback *get_global_ota_callback() {
 void register_ota_platform(OTAComponent *ota_caller) { get_global_ota_callback()->register_ota(ota_caller); }
 #endif
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome

esphome/components/ota_base/ota_backend.h

@@ -9,7 +9,7 @@
 #endif
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 enum OTAResponseTypes {
   OTA_RESPONSE_OK = 0x00,
@@ -59,15 +59,38 @@ class OTABackend {
   virtual bool supports_compression() = 0;
 };
 
+std::unique_ptr<OTABackend> make_ota_backend();
+
 class OTAComponent : public Component {
 #ifdef USE_OTA_STATE_CALLBACK
  public:
-  void add_on_state_callback(std::function<void(ota::OTAState, float, uint8_t)> &&callback) {
+  void add_on_state_callback(std::function<void(OTAState, float, uint8_t)> &&callback) {
     this->state_callback_.add(std::move(callback));
   }
 
  protected:
-  CallbackManager<void(ota::OTAState, float, uint8_t)> state_callback_{};
+  /** Extended callback manager with deferred call support.
+   *
+   * This adds a call_deferred() method for thread-safe execution from other tasks.
+   */
+  class StateCallbackManager : public CallbackManager<void(OTAState, float, uint8_t)> {
+   public:
+    StateCallbackManager(OTAComponent *component) : component_(component) {}
+
+    /** Call callbacks with deferral to main loop (for thread safety).
+     *
+     * This should be used by OTA implementations that run in separate tasks
+     * (like web_server OTA) to ensure callbacks execute in the main loop.
+     */
+    void call_deferred(OTAState state, float progress, uint8_t error) {
+      component_->defer([this, state, progress, error]() { this->call(state, progress, error); });
+    }
+
+   private:
+    OTAComponent *component_;
+  };
+
+  StateCallbackManager state_callback_{this};
 #endif
 };
 
@@ -89,8 +112,12 @@ class OTAGlobalCallback {
 
 OTAGlobalCallback *get_global_ota_callback();
 void register_ota_platform(OTAComponent *ota_caller);
-#endif
-std::unique_ptr<ota::OTABackend> make_ota_backend();
 
-}  // namespace ota
+// OTA implementations should use:
+// - state_callback_.call() when already in main loop (e.g., esphome OTA)
+// - state_callback_.call_deferred() when in separate task (e.g., web_server OTA)
+// This ensures proper callback execution in all contexts.
+#endif
+
+}  // namespace ota_base
 }  // namespace esphome

esphome/components/ota_base/ota_backend_arduino_esp32.cpp

@@ -8,13 +8,18 @@
 #include <Update.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 static const char *const TAG = "ota.arduino_esp32";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP32OTABackend>(); }
+std::unique_ptr<OTABackend> make_ota_backend() { return make_unique<ArduinoESP32OTABackend>(); }
 
 OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) which is used by web server OTA
+  // where the exact firmware size is unknown due to multipart encoding
+  if (image_size == 0) {
+    image_size = UPDATE_SIZE_UNKNOWN;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     return OTA_RESPONSE_OK;
@@ -29,7 +34,10 @@ OTAResponseTypes ArduinoESP32OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoESP32OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoESP32OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoESP32OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -44,7 +52,9 @@ OTAResponseTypes ArduinoESP32OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoESP32OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 
@@ -56,7 +66,7 @@ OTAResponseTypes ArduinoESP32OTABackend::end() {
 
 void ArduinoESP32OTABackend::abort() { Update.abort(); }
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/ota_base/ota_backend_arduino_esp32.h

@@ -6,7 +6,7 @@
 #include "esphome/core/helpers.h"
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 class ArduinoESP32OTABackend : public OTABackend {
  public:
@@ -16,9 +16,12 @@ class ArduinoESP32OTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_ESP32_FRAMEWORK_ARDUINO

esphome/components/ota_base/ota_backend_arduino_esp8266.cpp

@@ -10,13 +10,18 @@
 #include <Updater.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 static const char *const TAG = "ota.arduino_esp8266";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoESP8266OTABackend>(); }
+std::unique_ptr<OTABackend> make_ota_backend() { return make_unique<ArduinoESP8266OTABackend>(); }
 
 OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
+  if (image_size == 0) {
+    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
+    image_size = (ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     esp8266::preferences_prevent_write(true);
@@ -38,7 +43,10 @@ OTAResponseTypes ArduinoESP8266OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoESP8266OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoESP8266OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -53,13 +61,19 @@ OTAResponseTypes ArduinoESP8266OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoESP8266OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  bool success = Update.end(!this->md5_set_);
+
+  // On ESP8266, Update.end() might return false even with error code 0
+  // Check the actual error code to determine success
+  uint8_t error = Update.getError();
+
+  if (success || error == UPDATE_ERROR_OK) {
     return OTA_RESPONSE_OK;
   }
 
-  uint8_t error = Update.getError();
   ESP_LOGE(TAG, "End error: %d", error);
-
   return OTA_RESPONSE_ERROR_UPDATE_END;
 }
 
@@ -68,7 +82,7 @@ void ArduinoESP8266OTABackend::abort() {
   esp8266::preferences_prevent_write(false);
 }
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif

esphome/components/ota_base/ota_backend_arduino_esp8266.h

@@ -7,7 +7,7 @@
 #include "esphome/core/macros.h"
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 class ArduinoESP8266OTABackend : public OTABackend {
  public:
@@ -21,9 +21,12 @@ class ArduinoESP8266OTABackend : public OTABackend {
 #else
   bool supports_compression() override { return false; }
 #endif
+
+ private:
+  bool md5_set_{false};
 };
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif

esphome/components/ota_base/ota_backend_arduino_libretiny.cpp

@@ -8,13 +8,18 @@
 #include <Update.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 static const char *const TAG = "ota.arduino_libretiny";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoLibreTinyOTABackend>(); }
+std::unique_ptr<OTABackend> make_ota_backend() { return make_unique<ArduinoLibreTinyOTABackend>(); }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) which is used by web server OTA
+  // where the exact firmware size is unknown due to multipart encoding
+  if (image_size == 0) {
+    image_size = UPDATE_SIZE_UNKNOWN;
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     return OTA_RESPONSE_OK;
@@ -29,7 +34,10 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoLibreTinyOTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoLibreTinyOTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -44,7 +52,9 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoLibreTinyOTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 
@@ -56,7 +66,7 @@ OTAResponseTypes ArduinoLibreTinyOTABackend::end() {
 
 void ArduinoLibreTinyOTABackend::abort() { Update.abort(); }
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_LIBRETINY

esphome/components/ota_base/ota_backend_arduino_libretiny.h

@@ -5,7 +5,7 @@
 #include "esphome/core/defines.h"
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 class ArduinoLibreTinyOTABackend : public OTABackend {
  public:
@@ -15,9 +15,12 @@ class ArduinoLibreTinyOTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_LIBRETINY

esphome/components/ota_base/ota_backend_arduino_rp2040.cpp

@@ -10,13 +10,24 @@
 #include <Updater.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 static const char *const TAG = "ota.arduino_rp2040";
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::ArduinoRP2040OTABackend>(); }
+std::unique_ptr<OTABackend> make_ota_backend() { return make_unique<ArduinoRP2040OTABackend>(); }
 
 OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
+  // Handle UPDATE_SIZE_UNKNOWN (0) by calculating available space
+  if (image_size == 0) {
+    // Similar to ESP8266, calculate available space from flash layout
+    extern uint8_t _FS_start;
+    extern uint8_t _FS_end;
+    // Calculate the size of the filesystem area which will be used for OTA
+    size_t fs_size = &_FS_end - &_FS_start;
+    // Reserve some space for filesystem overhead
+    image_size = (fs_size - 0x1000) & 0xFFFFF000;
+    ESP_LOGD(TAG, "OTA size unknown, using filesystem size: %u bytes", image_size);
+  }
   bool ret = Update.begin(image_size, U_FLASH);
   if (ret) {
     rp2040::preferences_prevent_write(true);
@@ -38,7 +49,10 @@ OTAResponseTypes ArduinoRP2040OTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_ERROR_UNKNOWN;
 }
 
-void ArduinoRP2040OTABackend::set_update_md5(const char *md5) { Update.setMD5(md5); }
+void ArduinoRP2040OTABackend::set_update_md5(const char *md5) {
+  Update.setMD5(md5);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes ArduinoRP2040OTABackend::write(uint8_t *data, size_t len) {
   size_t written = Update.write(data, len);
@@ -53,7 +67,9 @@ OTAResponseTypes ArduinoRP2040OTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes ArduinoRP2040OTABackend::end() {
-  if (Update.end()) {
+  // Use strict validation (false) when MD5 is set, lenient validation (true) when no MD5
+  // This matches the behavior of the old web_server OTA implementation
+  if (Update.end(!this->md5_set_)) {
     return OTA_RESPONSE_OK;
   }
 
@@ -68,7 +84,7 @@ void ArduinoRP2040OTABackend::abort() {
   rp2040::preferences_prevent_write(false);
 }
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_RP2040

esphome/components/ota_base/ota_backend_arduino_rp2040.h

@@ -7,7 +7,7 @@
 #include "esphome/core/macros.h"
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 class ArduinoRP2040OTABackend : public OTABackend {
  public:
@@ -17,9 +17,12 @@ class ArduinoRP2040OTABackend : public OTABackend {
   OTAResponseTypes end() override;
   void abort() override;
   bool supports_compression() override { return false; }
+
+ private:
+  bool md5_set_{false};
 };
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 
 #endif  // USE_RP2040

esphome/components/ota_base/ota_backend_esp_idf.cpp

@@ -9,9 +9,9 @@
 #include <spi_flash_mmap.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
-std::unique_ptr<ota::OTABackend> make_ota_backend() { return make_unique<ota::IDFOTABackend>(); }
+std::unique_ptr<OTABackend> make_ota_backend() { return make_unique<IDFOTABackend>(); }
 
 OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
   this->partition_ = esp_ota_get_next_update_partition(nullptr);
@@ -56,7 +56,10 @@ OTAResponseTypes IDFOTABackend::begin(size_t image_size) {
   return OTA_RESPONSE_OK;
 }
 
-void IDFOTABackend::set_update_md5(const char *expected_md5) { memcpy(this->expected_bin_md5_, expected_md5, 32); }
+void IDFOTABackend::set_update_md5(const char *expected_md5) {
+  memcpy(this->expected_bin_md5_, expected_md5, 32);
+  this->md5_set_ = true;
+}
 
 OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
   esp_err_t err = esp_ota_write(this->update_handle_, data, len);
@@ -73,10 +76,12 @@ OTAResponseTypes IDFOTABackend::write(uint8_t *data, size_t len) {
 }
 
 OTAResponseTypes IDFOTABackend::end() {
-  this->md5_.calculate();
+  if (this->md5_set_) {
-  if (!this->md5_.equals_hex(this->expected_bin_md5_)) {
+    this->md5_.calculate();
-    this->abort();
+    if (!this->md5_.equals_hex(this->expected_bin_md5_)) {
-    return OTA_RESPONSE_ERROR_MD5_MISMATCH;
+      this->abort();
+      return OTA_RESPONSE_ERROR_MD5_MISMATCH;
+    }
   }
   esp_err_t err = esp_ota_end(this->update_handle_);
   this->update_handle_ = 0;
@@ -100,6 +105,6 @@ void IDFOTABackend::abort() {
   this->update_handle_ = 0;
 }
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 #endif

esphome/components/ota_base/ota_backend_esp_idf.h

@@ -8,7 +8,7 @@
 #include <esp_ota_ops.h>
 
 namespace esphome {
-namespace ota {
+namespace ota_base {
 
 class IDFOTABackend : public OTABackend {
  public:
@@ -24,8 +24,9 @@ class IDFOTABackend : public OTABackend {
   const esp_partition_t *partition_;
   md5::MD5Digest md5_{};
   char expected_bin_md5_[32];
+  bool md5_set_{false};
 };
 
-}  // namespace ota
+}  // namespace ota_base
 }  // namespace esphome
 #endif

esphome/components/runtime_stats/__init__.py

@@ -0,0 +1,26 @@
+"""
+Runtime statistics component for ESPHome.
+"""
+
+import esphome.codegen as cg
+import esphome.config_validation as cv
+
+DEPENDENCIES = []
+
+CONF_ENABLED = "enabled"
+CONF_LOG_INTERVAL = "log_interval"
+
+CONFIG_SCHEMA = cv.Schema(
+    {
+        cv.Optional(CONF_ENABLED, default=True): cv.boolean,
+        cv.Optional(
+            CONF_LOG_INTERVAL, default=60000
+        ): cv.positive_time_period_milliseconds,
+    }
+)
+
+
+async def to_code(config):
+    """Generate code for the runtime statistics component."""
+    cg.add(cg.App.set_runtime_stats_enabled(config[CONF_ENABLED]))
+    cg.add(cg.App.set_runtime_stats_log_interval(config[CONF_LOG_INTERVAL]))

esphome/components/speaker/media_player/speaker_media_player.cpp

@@ -6,7 +6,7 @@
 
 #include "esphome/components/audio/audio.h"
 #ifdef USE_OTA
-#include "esphome/components/ota/ota_backend.h"
+#include "esphome/components/ota_base/ota_backend.h"
 #endif
 
 namespace esphome {
@@ -67,16 +67,16 @@ void SpeakerMediaPlayer::setup() {
   }
 
 #ifdef USE_OTA
-  ota::get_global_ota_callback()->add_on_state_callback(
+  ota_base::get_global_ota_callback()->add_on_state_callback(
-      [this](ota::OTAState state, float progress, uint8_t error, ota::OTAComponent *comp) {
+      [this](ota_base::OTAState state, float progress, uint8_t error, ota_base::OTAComponent *comp) {
-        if (state == ota::OTA_STARTED) {
+        if (state == ota_base::OTA_STARTED) {
           if (this->media_pipeline_ != nullptr) {
             this->media_pipeline_->suspend_tasks();
           }
           if (this->announcement_pipeline_ != nullptr) {
             this->announcement_pipeline_->suspend_tasks();
           }
-        } else if (state == ota::OTA_ERROR) {
+        } else if (state == ota_base::OTA_ERROR) {
           if (this->media_pipeline_ != nullptr) {
             this->media_pipeline_->resume_tasks();
           }

esphome/components/web_server/__init__.py

@@ -34,7 +34,7 @@ from esphome.const import (
 from esphome.core import CORE, coroutine_with_priority
 import esphome.final_validate as fv
 
-AUTO_LOAD = ["json", "web_server_base"]
+AUTO_LOAD = ["json", "web_server_base", "ota_base"]
 
 CONF_SORTING_GROUP_ID = "sorting_group_id"
 CONF_SORTING_GROUPS = "sorting_groups"
@@ -274,7 +274,7 @@ async def to_code(config):
     cg.add(var.set_allow_ota(config[CONF_OTA]))
     if config[CONF_OTA]:
         # Define USE_WEBSERVER_OTA based only on web_server OTA config
-        # This allows web server OTA to work without loading the OTA component
+        # Web server OTA now uses ota_base backend for consistency
         cg.add_define("USE_WEBSERVER_OTA")
     cg.add(var.set_expose_log(config[CONF_LOG]))
     if config[CONF_ENABLE_PRIVATE_NETWORK_ACCESS]:

esphome/components/web_server_base/web_server_base.cpp

@@ -4,19 +4,16 @@
 #include "esphome/core/helpers.h"
 #include "esphome/core/log.h"
 
-#ifdef USE_ARDUINO
+#ifdef USE_WEBSERVER_OTA
-#include <StreamString.h>
+#include "esphome/components/ota_base/ota_backend.h"
-#if defined(USE_ESP32) || defined(USE_LIBRETINY)
-#include <Update.h>
-#endif
-#ifdef USE_ESP8266
-#include <Updater.h>
-#endif
 #endif
 
-#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
+#ifdef USE_ARDUINO
-#include <esp_ota_ops.h>
+#ifdef USE_ESP8266
-#include <esp_task_wdt.h>
+#include <Updater.h>
+#elif defined(USE_ESP32) || defined(USE_LIBRETINY)
+#include <Update.h>
+#endif
 #endif
 
 namespace esphome {
@@ -24,104 +21,6 @@ namespace web_server_base {
 
 static const char *const TAG = "web_server_base";
 
-#if defined(USE_ESP_IDF) && defined(USE_WEBSERVER_OTA)
-// Minimal OTA backend implementation for web server
-// This allows OTA updates via web server without requiring the OTA component
-// TODO: In the future, this should be refactored into a common ota_base component
-// that both web_server and ota components can depend on, avoiding code duplication
-// while keeping the components independent. This would allow both ESP-IDF and Arduino
-// implementations to share the base OTA functionality without requiring the full OTA component.
-// The IDFWebServerOTABackend class is intentionally designed with the same interface
-// as OTABackend to make it easy to swap to using OTABackend when the ota component
-// is split into ota and ota_base in the future.
-class IDFWebServerOTABackend {
- public:
-  bool begin() {
-    this->partition_ = esp_ota_get_next_update_partition(nullptr);
-    if (this->partition_ == nullptr) {
-      ESP_LOGE(TAG, "No OTA partition available");
-      return false;
-    }
-
-#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
-    // The following function takes longer than the default timeout of WDT due to flash erase
-#if ESP_IDF_VERSION_MAJOR >= 5
-    esp_task_wdt_config_t wdtc;
-    wdtc.idle_core_mask = 0;
-#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU0
-    wdtc.idle_core_mask |= (1 << 0);
-#endif
-#if CONFIG_ESP_TASK_WDT_CHECK_IDLE_TASK_CPU1
-    wdtc.idle_core_mask |= (1 << 1);
-#endif
-    wdtc.timeout_ms = 15000;
-    wdtc.trigger_panic = false;
-    esp_task_wdt_reconfigure(&wdtc);
-#else
-    esp_task_wdt_init(15, false);
-#endif
-#endif
-
-    esp_err_t err = esp_ota_begin(this->partition_, 0, &this->update_handle_);
-
-#if CONFIG_ESP_TASK_WDT_TIMEOUT_S < 15
-    // Set the WDT back to the configured timeout
-#if ESP_IDF_VERSION_MAJOR >= 5
-    wdtc.timeout_ms = CONFIG_ESP_TASK_WDT_TIMEOUT_S * 1000;
-    esp_task_wdt_reconfigure(&wdtc);
-#else
-    esp_task_wdt_init(CONFIG_ESP_TASK_WDT_TIMEOUT_S, false);
-#endif
-#endif
-
-    if (err != ESP_OK) {
-      esp_ota_abort(this->update_handle_);
-      this->update_handle_ = 0;
-      ESP_LOGE(TAG, "esp_ota_begin failed: %s", esp_err_to_name(err));
-      return false;
-    }
-    return true;
-  }
-
-  bool write(uint8_t *data, size_t len) {
-    esp_err_t err = esp_ota_write(this->update_handle_, data, len);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "esp_ota_write failed: %s", esp_err_to_name(err));
-      return false;
-    }
-    return true;
-  }
-
-  bool end() {
-    esp_err_t err = esp_ota_end(this->update_handle_);
-    this->update_handle_ = 0;
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "esp_ota_end failed: %s", esp_err_to_name(err));
-      return false;
-    }
-
-    err = esp_ota_set_boot_partition(this->partition_);
-    if (err != ESP_OK) {
-      ESP_LOGE(TAG, "esp_ota_set_boot_partition failed: %s", esp_err_to_name(err));
-      return false;
-    }
-
-    return true;
-  }
-
-  void abort() {
-    if (this->update_handle_ != 0) {
-      esp_ota_abort(this->update_handle_);
-      this->update_handle_ = 0;
-    }
-  }
-
- private:
-  esp_ota_handle_t update_handle_{0};
-  const esp_partition_t *partition_{nullptr};
-};
-#endif
-
 void WebServerBase::add_handler(AsyncWebHandler *handler) {
   // remove all handlers
 
@@ -138,12 +37,21 @@ void WebServerBase::add_handler(AsyncWebHandler *handler) {
 void OTARequestHandler::report_ota_progress_(AsyncWebServerRequest *request) {
   const uint32_t now = millis();
   if (now - this->last_ota_progress_ > 1000) {
+    float percentage = 0.0f;
     if (request->contentLength() != 0) {
-      float percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
+      // Note: Using contentLength() for progress calculation is technically wrong as it includes
+      // multipart headers/boundaries, but it's only off by a small amount and we don't have
+      // access to the actual firmware size until the upload is complete. This is intentional
+      // as it still gives the user a reasonable progress indication.
+      percentage = (this->ota_read_length_ * 100.0f) / request->contentLength();
       ESP_LOGD(TAG, "OTA in progress: %0.1f%%", percentage);
     } else {
       ESP_LOGD(TAG, "OTA in progress: %u bytes read", this->ota_read_length_);
     }
+#ifdef USE_OTA_STATE_CALLBACK
+    // Report progress - use call_deferred since we're in web server task
+    this->parent_->state_callback_.call_deferred(ota_base::OTA_IN_PROGRESS, percentage, 0);
+#endif
     this->last_ota_progress_ = now;
   }
 }
@@ -159,87 +67,72 @@ void OTARequestHandler::schedule_ota_reboot_() {
 void OTARequestHandler::ota_init_(const char *filename) {
   ESP_LOGI(TAG, "OTA Update Start: %s", filename);
   this->ota_read_length_ = 0;
-}
+  this->ota_success_ = false;
-
-void report_ota_error() {
-#ifdef USE_ARDUINO
-  StreamString ss;
-  Update.printError(ss);
-  ESP_LOGW(TAG, "OTA Update failed! Error: %s", ss.c_str());
-#endif
 }
 
 void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const String &filename, size_t index,
                                      uint8_t *data, size_t len, bool final) {
-#ifdef USE_ARDUINO
+  ota_base::OTAResponseTypes error_code = ota_base::OTA_RESPONSE_OK;
-  bool success;
+
-  if (index == 0) {
+  if (index == 0 && !this->ota_backend_) {
+    // Initialize OTA on first call
     this->ota_init_(filename.c_str());
+
+#ifdef USE_OTA_STATE_CALLBACK
+    // Notify OTA started - use call_deferred since we're in web server task
+    this->parent_->state_callback_.call_deferred(ota_base::OTA_STARTED, 0.0f, 0);
+#endif
+
+    // Platform-specific pre-initialization
+#ifdef USE_ARDUINO
 #ifdef USE_ESP8266
     Update.runAsync(true);
-    // NOLINTNEXTLINE(readability-static-accessed-through-instance)
-    success = Update.begin((ESP.getFreeSketchSpace() - 0x1000) & 0xFFFFF000);
 #endif
 #if defined(USE_ESP32_FRAMEWORK_ARDUINO) || defined(USE_LIBRETINY)
     if (Update.isRunning()) {
       Update.abort();
     }
-    success = Update.begin(UPDATE_SIZE_UNKNOWN, U_FLASH);
 #endif
-    if (!success) {
-      report_ota_error();
-      return;
-    }
-  } else if (Update.hasError()) {
-    // don't spam logs with errors if something failed at start
-    return;
-  }
-
-  success = Update.write(data, len) == len;
-  if (!success) {
-    report_ota_error();
-    return;
-  }
-  this->ota_read_length_ += len;
-  this->report_ota_progress_(request);
-
-  if (final) {
-    if (Update.end(true)) {
-      this->schedule_ota_reboot_();
-    } else {
-      report_ota_error();
-    }
-  }
 #endif  // USE_ARDUINO
 
-#ifdef USE_ESP_IDF
+    this->ota_backend_ = ota_base::make_ota_backend();
-  // ESP-IDF implementation
+    if (!this->ota_backend_) {
-  if (index == 0 && !this->ota_backend_) {
+      ESP_LOGE(TAG, "Failed to create OTA backend");
-    // Initialize OTA on first call
+#ifdef USE_OTA_STATE_CALLBACK
-    this->ota_init_(filename.c_str());
+      this->parent_->state_callback_.call_deferred(ota_base::OTA_ERROR, 0.0f,
-    this->ota_success_ = false;
+                                                   static_cast<uint8_t>(ota_base::OTA_RESPONSE_ERROR_UNKNOWN));
-
+#endif
-    auto *backend = new IDFWebServerOTABackend();
+      return;
-    if (!backend->begin()) {
+    }
-      ESP_LOGE(TAG, "OTA begin failed");
+
-      delete backend;
+    // Web server OTA uses multipart uploads where the actual firmware size
+    // is unknown (contentLength includes multipart overhead)
+    // Pass 0 to indicate unknown size
+    error_code = this->ota_backend_->begin(0);
+    if (error_code != ota_base::OTA_RESPONSE_OK) {
+      ESP_LOGE(TAG, "OTA begin failed: %d", error_code);
+      this->ota_backend_.reset();
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota_base::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
       return;
     }
-    this->ota_backend_ = backend;
   }
 
-  auto *backend = static_cast<IDFWebServerOTABackend *>(this->ota_backend_);
+  if (!this->ota_backend_) {
-  if (!backend) {
     return;
   }
 
   // Process data
   if (len > 0) {
-    if (!backend->write(data, len)) {
+    error_code = this->ota_backend_->write(data, len);
-      ESP_LOGE(TAG, "OTA write failed");
+    if (error_code != ota_base::OTA_RESPONSE_OK) {
-      backend->abort();
+      ESP_LOGE(TAG, "OTA write failed: %d", error_code);
-      delete backend;
+      this->ota_backend_->abort();
-      this->ota_backend_ = nullptr;
+      this->ota_backend_.reset();
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota_base::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
       return;
     }
     this->ota_read_length_ += len;
@@ -248,40 +141,45 @@ void OTARequestHandler::handleUpload(AsyncWebServerRequest *request, const Strin
 
   // Finalize
   if (final) {
-    this->ota_success_ = backend->end();
+    ESP_LOGD(TAG, "OTA final chunk: index=%u, len=%u, total_read=%u, contentLength=%u", index, len,
-    if (this->ota_success_) {
+             this->ota_read_length_, request->contentLength());
+
+    // For Arduino framework, the Update library tracks expected size from firmware header
+    // If we haven't received enough data, calling end() will fail
+    // This can happen if the upload is interrupted or the client disconnects
+    error_code = this->ota_backend_->end();
+    if (error_code == ota_base::OTA_RESPONSE_OK) {
+      this->ota_success_ = true;
+#ifdef USE_OTA_STATE_CALLBACK
+      // Report completion before reboot - use call_deferred since we're in web server task
+      this->parent_->state_callback_.call_deferred(ota_base::OTA_COMPLETED, 100.0f, 0);
+#endif
       this->schedule_ota_reboot_();
     } else {
-      ESP_LOGE(TAG, "OTA end failed");
+      ESP_LOGE(TAG, "OTA end failed: %d", error_code);
+#ifdef USE_OTA_STATE_CALLBACK
+      this->parent_->state_callback_.call_deferred(ota_base::OTA_ERROR, 0.0f, static_cast<uint8_t>(error_code));
+#endif
     }
-    delete backend;
+    this->ota_backend_.reset();
-    this->ota_backend_ = nullptr;
   }
-#endif  // USE_ESP_IDF
 }
 
 void OTARequestHandler::handleRequest(AsyncWebServerRequest *request) {
   AsyncWebServerResponse *response;
-#ifdef USE_ARDUINO
+  // Use the ota_success_ flag to determine the actual result
-  if (!Update.hasError()) {
+  const char *msg = this->ota_success_ ? "Update Successful!" : "Update Failed!";
-    response = request->beginResponse(200, "text/plain", "Update Successful!");
+  response = request->beginResponse(200, "text/plain", msg);
-  } else {
-    StreamString ss;
-    ss.print("Update Failed: ");
-    Update.printError(ss);
-    response = request->beginResponse(200, "text/plain", ss);
-  }
-#endif  // USE_ARDUINO
-#ifdef USE_ESP_IDF
-  // Send response based on the OTA result
-  response = request->beginResponse(200, "text/plain", this->ota_success_ ? "Update Successful!" : "Update Failed!");
-#endif  // USE_ESP_IDF
   response->addHeader("Connection", "close");
   request->send(response);
 }
 
 void WebServerBase::add_ota_handler() {
   this->add_handler(new OTARequestHandler(this));  // NOLINT
+#ifdef USE_OTA_STATE_CALLBACK
+  // Register with global OTA callback system
+  ota_base::register_ota_platform(this);
+#endif
 }
 #endif
 

esphome/components/web_server_base/web_server_base.h

@@ -14,6 +14,10 @@
 #include "esphome/components/web_server_idf/web_server_idf.h"
 #endif
 
+#ifdef USE_WEBSERVER_OTA
+#include "esphome/components/ota_base/ota_backend.h"
+#endif
+
 namespace esphome {
 namespace web_server_base {
 
@@ -79,7 +83,11 @@ class AuthMiddlewareHandler : public MiddlewareHandler {
 
 }  // namespace internal
 
+#ifdef USE_WEBSERVER_OTA
+class WebServerBase : public ota_base::OTAComponent {
+#else
 class WebServerBase : public Component {
+#endif
  public:
   void init() {
     if (this->initialized_) {
@@ -151,12 +159,10 @@ class OTARequestHandler : public AsyncWebHandler {
   uint32_t last_ota_progress_{0};
   uint32_t ota_read_length_{0};
   WebServerBase *parent_;
+  bool ota_success_{false};
 
  private:
-#ifdef USE_ESP_IDF
+  std::unique_ptr<ota_base::OTABackend> ota_backend_{nullptr};
-  void *ota_backend_{nullptr};
-  bool ota_success_{false};
-#endif
 };
 #endif  // USE_WEBSERVER_OTA
 

esphome/core/application.cpp

@@ -84,6 +84,10 @@ void Application::setup() {
   }
 
   ESP_LOGI(TAG, "setup() finished successfully!");
+
+  // Clear setup priority overrides to free memory
+  clear_setup_priority_overrides();
+
   this->schedule_dump_config();
   this->calculate_looping_components_();
 }
@@ -137,6 +141,10 @@ void Application::loop() {
   this->in_loop_ = false;
   this->app_state_ = new_app_state;
 
+  // Process any pending runtime stats printing after all components have run
+  // This ensures stats printing doesn't affect component timing measurements
+  runtime_stats.process_pending_stats(last_op_end_time);
+
   // Use the last component's end time instead of calling millis() again
   auto elapsed = last_op_end_time - this->last_loop_;
   if (elapsed >= this->loop_interval_ || HighFrequencyLoopRequester::is_high_frequency()) {

esphome/core/application.h

@@ -9,6 +9,7 @@
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
 #include "esphome/core/preferences.h"
+#include "esphome/core/runtime_stats.h"
 #include "esphome/core/scheduler.h"
 
 #ifdef USE_DEVICES
@@ -348,6 +349,18 @@ class Application {
 
   uint32_t get_loop_interval() const { return static_cast<uint32_t>(this->loop_interval_); }
 
+  /** Enable or disable runtime statistics collection.
+   *
+   * @param enable Whether to enable runtime statistics collection.
+   */
+  void set_runtime_stats_enabled(bool enable) { runtime_stats.set_enabled(enable); }
+
+  /** Set the interval at which runtime statistics are logged.
+   *
+   * @param interval The interval in milliseconds between logging of runtime statistics.
+   */
+  void set_runtime_stats_log_interval(uint32_t interval) { runtime_stats.set_log_interval(interval); }
+
   void schedule_dump_config() { this->dump_config_at_ = 0; }
 
   void feed_wdt(uint32_t time = 0);

esphome/core/component.cpp

@@ -2,7 +2,9 @@
 
 #include <cinttypes>
 #include <limits>
+#include <memory>
 #include <utility>
+#include <vector>
 #include "esphome/core/application.h"
 #include "esphome/core/hal.h"
 #include "esphome/core/helpers.h"
@@ -12,6 +14,30 @@ namespace esphome {
 
 static const char *const TAG = "component";
 
+// Global vectors for component data that doesn't belong in every instance.
+// Using vector instead of unordered_map for both because:
+// - Much lower memory overhead (8 bytes per entry vs 20+ for unordered_map)
+// - Linear search is fine for small n (typically < 5 entries)
+// - These are rarely accessed (setup only or error cases only)
+
+// Component error messages - only stores messages for failed components
+// Lazy allocated since most configs have zero failures
+// Note: We don't clear this vector because:
+// 1. Components are never destroyed in ESPHome
+// 2. Failed components remain failed (no recovery mechanism)
+// 3. Memory usage is minimal (only failures with custom messages are stored)
+static std::unique_ptr<std::vector<std::pair<const Component *, const char *>>> &get_component_error_messages() {
+  static std::unique_ptr<std::vector<std::pair<const Component *, const char *>>> instance;
+  return instance;
+}
+
+// Setup priority overrides - freed after setup completes
+// Typically < 5 entries, lazy allocated
+static std::unique_ptr<std::vector<std::pair<const Component *, float>>> &get_setup_priority_overrides() {
+  static std::unique_ptr<std::vector<std::pair<const Component *, float>>> instance;
+  return instance;
+}
+
 namespace setup_priority {
 
 const float BUS = 1000.0f;
@@ -102,8 +128,17 @@ void Component::call_setup() { this->setup(); }
 void Component::call_dump_config() {
   this->dump_config();
   if (this->is_failed()) {
-    ESP_LOGE(TAG, "  Component %s is marked FAILED: %s", this->get_component_source(),
+    // Look up error message from global vector
-             this->error_message_ ? this->error_message_ : "unspecified");
+    const char *error_msg = "unspecified";
+    if (get_component_error_messages()) {
+      for (const auto &pair : *get_component_error_messages()) {
+        if (pair.first == this) {
+          error_msg = pair.second;
+          break;
+        }
+      }
+    }
+    ESP_LOGE(TAG, "  Component %s is marked FAILED: %s", this->get_component_source(), error_msg);
   }
 }
 
@@ -245,8 +280,21 @@ void Component::status_set_error(const char *message) {
   this->component_state_ |= STATUS_LED_ERROR;
   App.app_state_ |= STATUS_LED_ERROR;
   ESP_LOGE(TAG, "Component %s set Error flag: %s", this->get_component_source(), message);
-  if (strcmp(message, "unspecified") != 0)
+  if (strcmp(message, "unspecified") != 0) {
-    this->error_message_ = message;
+    // Lazy allocate the error messages vector if needed
+    if (!get_component_error_messages()) {
+      get_component_error_messages() = std::make_unique<std::vector<std::pair<const Component *, const char *>>>();
+    }
+    // Check if this component already has an error message
+    for (auto &pair : *get_component_error_messages()) {
+      if (pair.first == this) {
+        pair.second = message;
+        return;
+      }
+    }
+    // Add new error message
+    get_component_error_messages()->emplace_back(this, message);
+  }
 }
 void Component::status_clear_warning() {
   if ((this->component_state_ & STATUS_LED_WARNING) == 0)
@@ -270,11 +318,36 @@ void Component::status_momentary_error(const std::string &name, uint32_t length)
 }
 void Component::dump_config() {}
 float Component::get_actual_setup_priority() const {
-  if (std::isnan(this->setup_priority_override_))
+  // Check if there's an override in the global vector
-    return this->get_setup_priority();
+  if (get_setup_priority_overrides()) {
-  return this->setup_priority_override_;
+    // Linear search is fine for small n (typically < 5 overrides)
+    for (const auto &pair : *get_setup_priority_overrides()) {
+      if (pair.first == this) {
+        return pair.second;
+      }
+    }
+  }
+  return this->get_setup_priority();
+}
+void Component::set_setup_priority(float priority) {
+  // Lazy allocate the vector if needed
+  if (!get_setup_priority_overrides()) {
+    get_setup_priority_overrides() = std::make_unique<std::vector<std::pair<const Component *, float>>>();
+    // Reserve some space to avoid reallocations (most configs have < 10 overrides)
+    get_setup_priority_overrides()->reserve(10);
+  }
+
+  // Check if this component already has an override
+  for (auto &pair : *get_setup_priority_overrides()) {
+    if (pair.first == this) {
+      pair.second = priority;
+      return;
+    }
+  }
+
+  // Add new override
+  get_setup_priority_overrides()->emplace_back(this, priority);
 }
-void Component::set_setup_priority(float priority) { this->setup_priority_override_ = priority; }
 
 bool Component::has_overridden_loop() const {
 #if defined(USE_HOST) || defined(CLANG_TIDY)
@@ -319,6 +392,9 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
   uint32_t curr_time = millis();
 
   uint32_t blocking_time = curr_time - this->started_;
+
+  // Record component runtime stats
+  runtime_stats.record_component_time(this->component_, blocking_time, curr_time);
   bool should_warn;
   if (this->component_ != nullptr) {
     should_warn = this->component_->should_warn_of_blocking(blocking_time);
@@ -336,4 +412,9 @@ uint32_t WarnIfComponentBlockingGuard::finish() {
 
 WarnIfComponentBlockingGuard::~WarnIfComponentBlockingGuard() {}
 
+void clear_setup_priority_overrides() {
+  // Free the setup priority map completely
+  get_setup_priority_overrides().reset();
+}
+
 }  // namespace esphome

esphome/core/component.h

@@ -6,6 +6,7 @@
 #include <string>
 
 #include "esphome/core/optional.h"
+#include "esphome/core/runtime_stats.h"
 
 namespace esphome {
 
@@ -387,9 +388,7 @@ class Component {
   bool cancel_defer(const std::string &name);  // NOLINT
 
   // Ordered for optimal packing on 32-bit systems
-  float setup_priority_override_{NAN};
   const char *component_source_{nullptr};
-  const char *error_message_{nullptr};
   uint16_t warn_if_blocking_over_{WARN_IF_BLOCKING_OVER_MS};  ///< Warn if blocked for this many ms (max 65.5s)
   /// State of this component - each bit has a purpose:
   /// Bits 0-1: Component state (0x00=CONSTRUCTION, 0x01=SETUP, 0x02=LOOP, 0x03=FAILED)
@@ -459,4 +458,7 @@ class WarnIfComponentBlockingGuard {
   Component *component_;
 };
 
+// Function to clear setup priority overrides after all components are set up
+void clear_setup_priority_overrides();
+
 }  // namespace esphome

esphome/core/runtime_stats.cpp

@@ -0,0 +1,92 @@
+#include "esphome/core/runtime_stats.h"
+#include "esphome/core/component.h"
+#include <algorithm>
+
+namespace esphome {
+
+RuntimeStatsCollector runtime_stats;
+
+void RuntimeStatsCollector::record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time) {
+  if (!this->enabled_ || component == nullptr)
+    return;
+
+  // Check if we have cached the name for this component
+  auto name_it = this->component_names_cache_.find(component);
+  if (name_it == this->component_names_cache_.end()) {
+    // First time seeing this component, cache its name
+    const char *source = component->get_component_source();
+    this->component_names_cache_[component] = source;
+    this->component_stats_[source].record_time(duration_ms);
+  } else {
+    // Use cached name - no string operations, just map lookup
+    this->component_stats_[name_it->second].record_time(duration_ms);
+  }
+
+  // If next_log_time_ is 0, initialize it
+  if (this->next_log_time_ == 0) {
+    this->next_log_time_ = current_time + this->log_interval_;
+    return;
+  }
+
+  // Don't print stats here anymore - let process_pending_stats handle it
+}
+
+void RuntimeStatsCollector::log_stats_() {
+  ESP_LOGI(RUNTIME_TAG, "Component Runtime Statistics");
+  ESP_LOGI(RUNTIME_TAG, "Period stats (last %" PRIu32 "ms):", this->log_interval_);
+
+  // First collect stats we want to display
+  std::vector<ComponentStatPair> stats_to_display;
+
+  for (const auto &it : this->component_stats_) {
+    const ComponentRuntimeStats &stats = it.second;
+    if (stats.get_period_count() > 0) {
+      ComponentStatPair pair = {it.first, &stats};
+      stats_to_display.push_back(pair);
+    }
+  }
+
+  // Sort by period runtime (descending)
+  std::sort(stats_to_display.begin(), stats_to_display.end(), std::greater<ComponentStatPair>());
+
+  // Log top components by period runtime
+  for (const auto &it : stats_to_display) {
+    const std::string &source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source.c_str(),
+             stats->get_period_count(), stats->get_period_avg_time_ms(), stats->get_period_max_time_ms(),
+             stats->get_period_time_ms());
+  }
+
+  // Log total stats since boot
+  ESP_LOGI(RUNTIME_TAG, "Total stats (since boot):");
+
+  // Re-sort by total runtime for all-time stats
+  std::sort(stats_to_display.begin(), stats_to_display.end(),
+            [](const ComponentStatPair &a, const ComponentStatPair &b) {
+              return a.stats->get_total_time_ms() > b.stats->get_total_time_ms();
+            });
+
+  for (const auto &it : stats_to_display) {
+    const std::string &source = it.name;
+    const ComponentRuntimeStats *stats = it.stats;
+
+    ESP_LOGI(RUNTIME_TAG, "  %s: count=%" PRIu32 ", avg=%.2fms, max=%" PRIu32 "ms, total=%" PRIu32 "ms", source.c_str(),
+             stats->get_total_count(), stats->get_total_avg_time_ms(), stats->get_total_max_time_ms(),
+             stats->get_total_time_ms());
+  }
+}
+
+void RuntimeStatsCollector::process_pending_stats(uint32_t current_time) {
+  if (!this->enabled_ || this->next_log_time_ == 0)
+    return;
+
+  if (current_time >= this->next_log_time_) {
+    this->log_stats_();
+    this->reset_stats_();
+    this->next_log_time_ = current_time + this->log_interval_;
+  }
+}
+
+}  // namespace esphome

esphome/core/runtime_stats.h

@@ -0,0 +1,121 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <vector>
+#include <cstdint>
+#include <algorithm>
+#include "esphome/core/helpers.h"
+#include "esphome/core/log.h"
+
+namespace esphome {
+
+static const char *const RUNTIME_TAG = "runtime";
+
+class Component;  // Forward declaration
+
+class ComponentRuntimeStats {
+ public:
+  ComponentRuntimeStats()
+      : period_count_(0),
+        total_count_(0),
+        period_time_ms_(0),
+        total_time_ms_(0),
+        period_max_time_ms_(0),
+        total_max_time_ms_(0) {}
+
+  void record_time(uint32_t duration_ms) {
+    // Update period counters
+    this->period_count_++;
+    this->period_time_ms_ += duration_ms;
+    if (duration_ms > this->period_max_time_ms_)
+      this->period_max_time_ms_ = duration_ms;
+
+    // Update total counters
+    this->total_count_++;
+    this->total_time_ms_ += duration_ms;
+    if (duration_ms > this->total_max_time_ms_)
+      this->total_max_time_ms_ = duration_ms;
+  }
+
+  void reset_period_stats() {
+    this->period_count_ = 0;
+    this->period_time_ms_ = 0;
+    this->period_max_time_ms_ = 0;
+  }
+
+  // Period stats (reset each logging interval)
+  uint32_t get_period_count() const { return this->period_count_; }
+  uint32_t get_period_time_ms() const { return this->period_time_ms_; }
+  uint32_t get_period_max_time_ms() const { return this->period_max_time_ms_; }
+  float get_period_avg_time_ms() const {
+    return this->period_count_ > 0 ? this->period_time_ms_ / static_cast<float>(this->period_count_) : 0.0f;
+  }
+
+  // Total stats (persistent until reboot)
+  uint32_t get_total_count() const { return this->total_count_; }
+  uint32_t get_total_time_ms() const { return this->total_time_ms_; }
+  uint32_t get_total_max_time_ms() const { return this->total_max_time_ms_; }
+  float get_total_avg_time_ms() const {
+    return this->total_count_ > 0 ? this->total_time_ms_ / static_cast<float>(this->total_count_) : 0.0f;
+  }
+
+ protected:
+  // Period stats (reset each logging interval)
+  uint32_t period_count_;
+  uint32_t period_time_ms_;
+  uint32_t period_max_time_ms_;
+
+  // Total stats (persistent until reboot)
+  uint32_t total_count_;
+  uint32_t total_time_ms_;
+  uint32_t total_max_time_ms_;
+};
+
+// For sorting components by run time
+struct ComponentStatPair {
+  std::string name;
+  const ComponentRuntimeStats *stats;
+
+  bool operator>(const ComponentStatPair &other) const {
+    // Sort by period time as that's what we're displaying in the logs
+    return stats->get_period_time_ms() > other.stats->get_period_time_ms();
+  }
+};
+
+class RuntimeStatsCollector {
+ public:
+  RuntimeStatsCollector() : log_interval_(60000), next_log_time_(0), enabled_(true) {}
+
+  void set_log_interval(uint32_t log_interval) { this->log_interval_ = log_interval; }
+  uint32_t get_log_interval() const { return this->log_interval_; }
+
+  void set_enabled(bool enabled) { this->enabled_ = enabled; }
+  bool is_enabled() const { return this->enabled_; }
+
+  void record_component_time(Component *component, uint32_t duration_ms, uint32_t current_time);
+
+  // Process any pending stats printing (should be called after component loop)
+  void process_pending_stats(uint32_t current_time);
+
+ protected:
+  void log_stats_();
+
+  void reset_stats_() {
+    for (auto &it : this->component_stats_) {
+      it.second.reset_period_stats();
+    }
+  }
+
+  // Back to string keys, but we'll cache the source name per component
+  std::map<std::string, ComponentRuntimeStats> component_stats_;
+  std::map<Component *, std::string> component_names_cache_;
+  uint32_t log_interval_;
+  uint32_t next_log_time_;
+  bool enabled_;
+};
+
+// Global instance for runtime stats collection
+extern RuntimeStatsCollector runtime_stats;
+
+}  // namespace esphome

script/api_protobuf/api_protobuf.py

@@ -526,9 +526,13 @@ class BytesType(TypeInfo):
     reference_type = "std::string &"
     const_reference_type = "const std::string &"
     decode_length = "value.as_string()"
-    encode_func = "encode_string"
+    encode_func = "encode_bytes"
     wire_type = WireType.LENGTH_DELIMITED  # Uses wire type 2
 
+    @property
+    def encode_content(self) -> str:
+        return f"buffer.encode_bytes({self.number}, reinterpret_cast<const uint8_t*>(this->{self.field_name}.data()), this->{self.field_name}.size());"
+
     def dump(self, name: str) -> str:
         o = f'out.append("\'").append({name}).append("\'");'
         return o

tests/components/ota_base/common.yaml

@@ -0,0 +1,10 @@
+# Test that ota_base compiles correctly as a dependency
+# This component is typically auto-loaded by other components
+
+wifi:
+  ssid: MySSID
+  password: password1
+
+ota:
+  - platform: esphome
+    password: "test1234"

tests/components/ota_base/test.esp32-idf.yaml

@@ -0,0 +1 @@
+<<: !include common.yaml