esphome 2025.9.3__py3-none-any.whl → 2025.10.0b2__py3-none-any.whl

esphome/components/api/api_server.h

@@ -16,6 +16,7 @@
 #include "user_services.h"
 #endif
 
+#include <map>
 #include <vector>
 
 namespace esphome::api {
@@ -37,13 +38,15 @@ class APIServer : public Component, public Controller {
   void on_shutdown() override;
   bool teardown() override;
 #ifdef USE_API_PASSWORD
-  bool check_password(const std::string &password) const;
+  bool check_password(const uint8_t *password_data, size_t password_len) const;
   void set_password(const std::string &password);
 #endif
   void set_port(uint16_t port);
   void set_reboot_timeout(uint32_t reboot_timeout);
   void set_batch_delay(uint16_t batch_delay);
   uint16_t get_batch_delay() const { return batch_delay_; }
+  void set_listen_backlog(uint8_t listen_backlog) { this->listen_backlog_ = listen_backlog; }
+  void set_max_connections(uint8_t max_connections) { this->max_connections_ = max_connections; }
 
   // Get reference to shared buffer for API connections
   std::vector<uint8_t> &get_shared_buffer_ref() { return shared_write_buffer_; }
@@ -107,8 +110,19 @@ class APIServer : public Component, public Controller {
   void on_media_player_update(media_player::MediaPlayer *obj) override;
 #endif
 #ifdef USE_API_HOMEASSISTANT_SERVICES
-  void send_homeassistant_service_call(const HomeassistantServiceResponse &call);
-#endif
+  void send_homeassistant_action(const HomeassistantActionRequest &call);
+
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+  // Action response handling
+  using ActionResponseCallback = std::function<void(const class ActionResponse &)>;
+  void register_action_response_callback(uint32_t call_id, ActionResponseCallback callback);
+  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message);
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  void handle_action_response(uint32_t call_id, bool success, const std::string &error_message,
+                              const uint8_t *response_data, size_t response_data_len);
+#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
+#endif  // USE_API_HOMEASSISTANT_SERVICES
 #ifdef USE_API_SERVICES
   void register_user_service(UserServiceDescriptor *descriptor) { this->user_services_.push_back(descriptor); }
 #endif
@@ -125,6 +139,9 @@ class APIServer : public Component, public Controller {
 #ifdef USE_UPDATE
   void on_update(update::UpdateEntity *obj) override;
 #endif
+#ifdef USE_ZWAVE_PROXY
+  void on_zwave_proxy_request(const esphome::api::ProtoMessage &msg);
+#endif
 
   bool is_connected() const;
 
@@ -181,12 +198,23 @@ class APIServer : public Component, public Controller {
 #ifdef USE_API_SERVICES
   std::vector<UserServiceDescriptor *> user_services_;
 #endif
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+  struct PendingActionResponse {
+    uint32_t call_id;
+    ActionResponseCallback callback;
+  };
+  std::vector<PendingActionResponse> action_response_callbacks_;
+#endif
 
   // Group smaller types together
   uint16_t port_{6053};
   uint16_t batch_delay_{100};
+  // Connection limits - these defaults will be overridden by config values
+  // from cv.SplitDefault in __init__.py which sets platform-specific defaults
+  uint8_t listen_backlog_{4};
+  uint8_t max_connections_{8};
   bool shutting_down_ = false;
-  // 5 bytes used, 3 bytes padding
+  // 7 bytes used, 1 byte padding
 
 #ifdef USE_API_NOISE
   std::shared_ptr<APINoiseContext> noise_ctx_ = std::make_shared<APINoiseContext>();

esphome/components/api/custom_api_device.h

@@ -179,9 +179,9 @@ class CustomAPIDevice {
    * @param service_name The service to call.
    */
   void call_homeassistant_service(const std::string &service_name) {
-    HomeassistantServiceResponse resp;
+    HomeassistantActionRequest resp;
     resp.set_service(StringRef(service_name));
-    global_api_server->send_homeassistant_service_call(resp);
+    global_api_server->send_homeassistant_action(resp);
   }
 
   /** Call a Home Assistant service from ESPHome.
@@ -199,7 +199,7 @@ class CustomAPIDevice {
    * @param data The data for the service call, mapping from string to string.
    */
   void call_homeassistant_service(const std::string &service_name, const std::map<std::string, std::string> &data) {
-    HomeassistantServiceResponse resp;
+    HomeassistantActionRequest resp;
     resp.set_service(StringRef(service_name));
     for (auto &it : data) {
       resp.data.emplace_back();
@@ -207,7 +207,7 @@ class CustomAPIDevice {
       kv.set_key(StringRef(it.first));
       kv.value = it.second;
     }
-    global_api_server->send_homeassistant_service_call(resp);
+    global_api_server->send_homeassistant_action(resp);
   }
 
   /** Fire an ESPHome event in Home Assistant.
@@ -221,10 +221,10 @@ class CustomAPIDevice {
    * @param event_name The event to fire.
    */
   void fire_homeassistant_event(const std::string &event_name) {
-    HomeassistantServiceResponse resp;
+    HomeassistantActionRequest resp;
     resp.set_service(StringRef(event_name));
     resp.is_event = true;
-    global_api_server->send_homeassistant_service_call(resp);
+    global_api_server->send_homeassistant_action(resp);
   }
 
   /** Fire an ESPHome event in Home Assistant.
@@ -241,7 +241,7 @@ class CustomAPIDevice {
    * @param data The data for the event, mapping from string to string.
    */
   void fire_homeassistant_event(const std::string &service_name, const std::map<std::string, std::string> &data) {
-    HomeassistantServiceResponse resp;
+    HomeassistantActionRequest resp;
     resp.set_service(StringRef(service_name));
     resp.is_event = true;
     for (auto &it : data) {
@@ -250,7 +250,7 @@ class CustomAPIDevice {
       kv.set_key(StringRef(it.first));
       kv.value = it.second;
     }
-    global_api_server->send_homeassistant_service_call(resp);
+    global_api_server->send_homeassistant_action(resp);
   }
 #else
   template<typename T = void> void call_homeassistant_service(const std::string &service_name) {

esphome/components/api/homeassistant_service.h

@@ -3,10 +3,15 @@
 #include "api_server.h"
 #ifdef USE_API
 #ifdef USE_API_HOMEASSISTANT_SERVICES
+#include <functional>
+#include <utility>
+#include <vector>
 #include "api_pb2.h"
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+#include "esphome/components/json/json_util.h"
+#endif
 #include "esphome/core/automation.h"
 #include "esphome/core/helpers.h"
-#include <vector>
 
 namespace esphome::api {
 
@@ -44,9 +49,47 @@ template<typename... Ts> class TemplatableKeyValuePair {
   TemplatableStringValue<Ts...> value;
 };
 
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+// Represents the response data from a Home Assistant action
+class ActionResponse {
+ public:
+  ActionResponse(bool success, std::string error_message = "")
+      : success_(success), error_message_(std::move(error_message)) {}
+
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  ActionResponse(bool success, std::string error_message, const uint8_t *data, size_t data_len)
+      : success_(success), error_message_(std::move(error_message)) {
+    if (data == nullptr || data_len == 0)
+      return;
+    this->json_document_ = json::parse_json(data, data_len);
+  }
+#endif
+
+  bool is_success() const { return this->success_; }
+  const std::string &get_error_message() const { return this->error_message_; }
+
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  // Get data as parsed JSON object (const version returns read-only view)
+  JsonObjectConst get_json() const { return this->json_document_.as<JsonObjectConst>(); }
+#endif
+
+ protected:
+  bool success_;
+  std::string error_message_;
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  JsonDocument json_document_;
+#endif
+};
+
+// Callback type for action responses
+template<typename... Ts> using ActionResponseCallback = std::function<void(const ActionResponse &, Ts...)>;
+#endif
+
 template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts...> {
  public:
-  explicit HomeAssistantServiceCallAction(APIServer *parent, bool is_event) : parent_(parent), is_event_(is_event) {}
+  explicit HomeAssistantServiceCallAction(APIServer *parent, bool is_event) : parent_(parent) {
+    this->flags_.is_event = is_event;
+  }
 
   template<typename T> void set_service(T service) { this->service_ = service; }
 
@@ -61,11 +104,29 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
     this->variables_.emplace_back(std::move(key), value);
   }
 
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+  template<typename T> void set_response_template(T response_template) {
+    this->response_template_ = response_template;
+    this->flags_.has_response_template = true;
+  }
+
+  void set_wants_status() { this->flags_.wants_status = true; }
+  void set_wants_response() { this->flags_.wants_response = true; }
+
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  Trigger<JsonObjectConst, Ts...> *get_success_trigger_with_response() const {
+    return this->success_trigger_with_response_;
+  }
+#endif
+  Trigger<Ts...> *get_success_trigger() const { return this->success_trigger_; }
+  Trigger<std::string, Ts...> *get_error_trigger() const { return this->error_trigger_; }
+#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
+
   void play(Ts... x) override {
-    HomeassistantServiceResponse resp;
+    HomeassistantActionRequest resp;
     std::string service_value = this->service_.value(x...);
     resp.set_service(StringRef(service_value));
-    resp.is_event = this->is_event_;
+    resp.is_event = this->flags_.is_event;
     for (auto &it : this->data_) {
       resp.data.emplace_back();
       auto &kv = resp.data.back();
@@ -84,18 +145,74 @@ template<typename... Ts> class HomeAssistantServiceCallAction : public Action<Ts
       kv.set_key(StringRef(it.key));
       kv.value = it.value.value(x...);
     }
-    this->parent_->send_homeassistant_service_call(resp);
+
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+    if (this->flags_.wants_status) {
+      // Generate a unique call ID for this service call
+      static uint32_t call_id_counter = 1;
+      uint32_t call_id = call_id_counter++;
+      resp.call_id = call_id;
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+      if (this->flags_.wants_response) {
+        resp.wants_response = true;
+        // Set response template if provided
+        if (this->flags_.has_response_template) {
+          std::string response_template_value = this->response_template_.value(x...);
+          resp.response_template = response_template_value;
+        }
+      }
+#endif
+
+      auto captured_args = std::make_tuple(x...);
+      this->parent_->register_action_response_callback(call_id, [this, captured_args](const ActionResponse &response) {
+        std::apply(
+            [this, &response](auto &&...args) {
+              if (response.is_success()) {
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+                if (this->flags_.wants_response) {
+                  this->success_trigger_with_response_->trigger(response.get_json(), args...);
+                } else
+#endif
+                {
+                  this->success_trigger_->trigger(args...);
+                }
+              } else {
+                this->error_trigger_->trigger(response.get_error_message(), args...);
+              }
+            },
+            captured_args);
+      });
+    }
+#endif
+
+    this->parent_->send_homeassistant_action(resp);
   }
 
  protected:
   APIServer *parent_;
-  bool is_event_;
   TemplatableStringValue<Ts...> service_{};
   std::vector<TemplatableKeyValuePair<Ts...>> data_;
   std::vector<TemplatableKeyValuePair<Ts...>> data_template_;
   std::vector<TemplatableKeyValuePair<Ts...>> variables_;
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES
+#ifdef USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  TemplatableStringValue<Ts...> response_template_{""};
+  Trigger<JsonObjectConst, Ts...> *success_trigger_with_response_ = new Trigger<JsonObjectConst, Ts...>();
+#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES_JSON
+  Trigger<Ts...> *success_trigger_ = new Trigger<Ts...>();
+  Trigger<std::string, Ts...> *error_trigger_ = new Trigger<std::string, Ts...>();
+#endif  // USE_API_HOMEASSISTANT_ACTION_RESPONSES
+
+  struct Flags {
+    uint8_t is_event : 1;
+    uint8_t wants_status : 1;
+    uint8_t wants_response : 1;
+    uint8_t has_response_template : 1;
+    uint8_t reserved : 5;
+  } flags_{0};
 };
 
 }  // namespace esphome::api
+
 #endif
 #endif

esphome/components/api/proto.h

@@ -182,6 +182,10 @@ class ProtoLengthDelimited {
   explicit ProtoLengthDelimited(const uint8_t *value, size_t length) : value_(value), length_(length) {}
   std::string as_string() const { return std::string(reinterpret_cast<const char *>(this->value_), this->length_); }
 
+  // Direct access to raw data without string allocation
+  const uint8_t *data() const { return this->value_; }
+  size_t size() const { return this->length_; }
+
   /**
    * Decode the length-delimited data into an existing ProtoDecodableMessage instance.
    *
@@ -827,7 +831,7 @@ class ProtoService {
   }
 
   // Authentication helper methods
-  bool check_connection_setup_() {
+  inline bool check_connection_setup_() {
     if (!this->is_connection_setup()) {
       this->on_no_setup_connection();
       return false;
@@ -835,7 +839,7 @@ class ProtoService {
     return true;
   }
 
-  bool check_authenticated_() {
+  inline bool check_authenticated_() {
 #ifdef USE_API_PASSWORD
     if (!this->check_connection_setup_()) {
       return false;

esphome/components/api/user_services.h

@@ -35,7 +35,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
     msg.set_name(StringRef(this->name_));
     msg.key = this->key_;
     std::array<enums::ServiceArgType, sizeof...(Ts)> arg_types = {to_service_arg_type<Ts>()...};
-    for (int i = 0; i < sizeof...(Ts); i++) {
+    for (size_t i = 0; i < sizeof...(Ts); i++) {
       msg.args.emplace_back();
       auto &arg = msg.args.back();
       arg.type = arg_types[i];
@@ -55,7 +55,7 @@ template<typename... Ts> class UserServiceBase : public UserServiceDescriptor {
 
  protected:
   virtual void execute(Ts... x) = 0;
-  template<int... S> void execute_(std::vector<ExecuteServiceArgument> args, seq<S...> type) {
+  template<int... S> void execute_(const std::vector<ExecuteServiceArgument> &args, seq<S...> type) {
     this->execute((get_execute_arg_value<Ts>(args[S]))...);
   }
 

esphome/components/as7341/sensor.py

@@ -2,6 +2,7 @@ import esphome.codegen as cg
 from esphome.components import i2c, sensor
 import esphome.config_validation as cv
 from esphome.const import (
+    CONF_CLEAR,
     CONF_GAIN,
     CONF_ID,
     DEVICE_CLASS_ILLUMINANCE,
@@ -29,7 +30,6 @@ CONF_F5 = "f5"
 CONF_F6 = "f6"
 CONF_F7 = "f7"
 CONF_F8 = "f8"
-CONF_CLEAR = "clear"
 CONF_NIR = "nir"
 
 UNIT_COUNTS = "#"

esphome/components/audio/__init__.py

@@ -165,4 +165,4 @@ def final_validate_audio_schema(
 
 
 async def to_code(config):
-    cg.add_library("esphome/esp-audio-libs", "1.1.4")
+    cg.add_library("esphome/esp-audio-libs", "2.0.1")

esphome/components/audio/audio.cpp

@@ -57,7 +57,7 @@ const char *audio_file_type_to_string(AudioFileType file_type) {
 void scale_audio_samples(const int16_t *audio_samples, int16_t *output_buffer, int16_t scale_factor,
                          size_t samples_to_scale) {
   // Note the assembly dsps_mulc function has audio glitches if the input and output buffers are the same.
-  for (int i = 0; i < samples_to_scale; i++) {
+  for (size_t i = 0; i < samples_to_scale; i++) {
     int32_t acc = (int32_t) audio_samples[i] * (int32_t) scale_factor;
     output_buffer[i] = (int16_t) (acc >> 15);
   }

esphome/components/audio/audio_decoder.cpp

@@ -229,18 +229,18 @@ FileDecoderState AudioDecoder::decode_flac_() {
     auto result = this->flac_decoder_->read_header(this->input_transfer_buffer_->get_buffer_start(),
                                                    this->input_transfer_buffer_->available());
 
-    if (result == esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
-      return FileDecoderState::POTENTIALLY_FAILED;
-    }
-
-    if (result != esp_audio_libs::flac::FLAC_DECODER_SUCCESS) {
-      // Couldn't read FLAC header
+    if (result > esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
+      // Serrious error reading FLAC header, there is no recovery
       return FileDecoderState::FAILED;
     }
 
     size_t bytes_consumed = this->flac_decoder_->get_bytes_index();
     this->input_transfer_buffer_->decrease_buffer_length(bytes_consumed);
 
+    if (result == esp_audio_libs::flac::FLAC_DECODER_HEADER_OUT_OF_DATA) {
+      return FileDecoderState::MORE_TO_PROCESS;
+    }
+
     // Reallocate the output transfer buffer to the smallest necessary size
     this->free_buffer_required_ = flac_decoder_->get_output_buffer_size_bytes();
     if (!this->output_transfer_buffer_->reallocate(this->free_buffer_required_)) {
@@ -256,9 +256,9 @@ FileDecoderState AudioDecoder::decode_flac_() {
   }
 
   uint32_t output_samples = 0;
-  auto result = this->flac_decoder_->decode_frame(
-      this->input_transfer_buffer_->get_buffer_start(), this->input_transfer_buffer_->available(),
-      reinterpret_cast<int16_t *>(this->output_transfer_buffer_->get_buffer_end()), &output_samples);
+  auto result = this->flac_decoder_->decode_frame(this->input_transfer_buffer_->get_buffer_start(),
+                                                  this->input_transfer_buffer_->available(),
+                                                  this->output_transfer_buffer_->get_buffer_end(), &output_samples);
 
   if (result == esp_audio_libs::flac::FLAC_DECODER_ERROR_OUT_OF_DATA) {
     // Not an issue, just needs more data that we'll get next time.

esphome/components/bl0906/bl0906.cpp

@@ -97,10 +97,10 @@ void BL0906::handle_actions_() {
     return;
   }
   ActionCallbackFuncPtr ptr_func = nullptr;
-  for (int i = 0; i < this->action_queue_.size(); i++) {
+  for (size_t i = 0; i < this->action_queue_.size(); i++) {
     ptr_func = this->action_queue_[i];
     if (ptr_func) {
-      ESP_LOGI(TAG, "HandleActionCallback[%d]", i);
+      ESP_LOGI(TAG, "HandleActionCallback[%zu]", i);
       (this->*ptr_func)();
     }
   }

esphome/components/bl0942/bl0942.cpp

@@ -51,7 +51,7 @@ void BL0942::loop() {
   if (!avail) {
     return;
   }
-  if (avail < sizeof(buffer)) {
+  if (static_cast<size_t>(avail) < sizeof(buffer)) {
     if (!this->rx_start_) {
       this->rx_start_ = millis();
     } else if (millis() > this->rx_start_ + PKT_TIMEOUT_MS) {
@@ -148,7 +148,7 @@ void BL0942::setup() {
 
   this->write_reg_(BL0942_REG_USR_WRPROT, 0);
 
-  if (this->read_reg_(BL0942_REG_MODE) != mode)
+  if (static_cast<uint32_t>(this->read_reg_(BL0942_REG_MODE)) != mode)
     this->status_set_warning(LOG_STR("BL0942 setup failed!"));
 
   this->flush();

esphome/components/ble_client/__init__.py

@@ -116,7 +116,7 @@ CONFIG_SCHEMA = cv.All(
     )
     .extend(cv.COMPONENT_SCHEMA)
     .extend(esp32_ble_tracker.ESP_BLE_DEVICE_SCHEMA),
-    esp32_ble_tracker.consume_connection_slots(1, "ble_client"),
+    esp32_ble.consume_connection_slots(1, "ble_client"),
 )
 
 CONF_BLE_CLIENT_ID = "ble_client_id"

esphome/components/bluetooth_proxy/__init__.py

@@ -6,8 +6,6 @@ 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
-from esphome.core import CORE
-from esphome.log import AnsiFore, color
 
 AUTO_LOAD = ["esp32_ble_client", "esp32_ble_tracker"]
 DEPENDENCIES = ["api", "esp32"]
@@ -44,29 +42,7 @@ def validate_connections(config):
             )
     elif config[CONF_ACTIVE]:
         connection_slots: int = config[CONF_CONNECTION_SLOTS]
-        esp32_ble_tracker.consume_connection_slots(connection_slots, "bluetooth_proxy")(
-            config
-        )
-
-        # Warn about connection slot waste when using Arduino framework
-        if CORE.using_arduino and connection_slots:
-            _LOGGER.warning(
-                "Bluetooth Proxy with active connections on Arduino framework has suboptimal performance.\n"
-                "If BLE connections fail, they can waste connection slots for 10 seconds because\n"
-                "Arduino doesn't allow configuring the BLE connection timeout (fixed at 30s).\n"
-                "ESP-IDF framework allows setting it to 20s to match client timeouts.\n"
-                "\n"
-                "To switch to ESP-IDF, add this to your YAML:\n"
-                "  esp32:\n"
-                "    framework:\n"
-                "      type: esp-idf\n"
-                "\n"
-                "For detailed migration instructions, see:\n"
-                "%s",
-                color(
-                    AnsiFore.BLUE, "https://esphome.io/guides/esp32_arduino_to_idf.html"
-                ),
-            )
+        esp32_ble.consume_connection_slots(connection_slots, "bluetooth_proxy")(config)
 
         return {
             **config,
@@ -81,19 +57,17 @@ CONFIG_SCHEMA = cv.All(
             {
                 cv.GenerateID(): cv.declare_id(BluetoothProxy),
                 cv.Optional(CONF_ACTIVE, default=True): cv.boolean,
-                cv.SplitDefault(CONF_CACHE_SERVICES, esp32_idf=True): cv.All(
-                    cv.only_with_esp_idf, cv.boolean
-                ),
+                cv.Optional(CONF_CACHE_SERVICES, default=True): cv.boolean,
                 cv.Optional(
                     CONF_CONNECTION_SLOTS,
                     default=DEFAULT_CONNECTION_SLOTS,
                 ): cv.All(
                     cv.positive_int,
-                    cv.Range(min=1, max=esp32_ble_tracker.max_connections()),
+                    cv.Range(min=1, max=esp32_ble.IDF_MAX_CONNECTIONS),
                 ),
                 cv.Optional(CONF_CONNECTIONS): cv.All(
                     cv.ensure_list(CONNECTION_SCHEMA),
-                    cv.Length(min=1, max=esp32_ble_tracker.max_connections()),
+                    cv.Length(min=1, max=esp32_ble.IDF_MAX_CONNECTIONS),
                 ),
             }
         )

esphome/components/bluetooth_proxy/bluetooth_connection.cpp

@@ -514,7 +514,8 @@ esp_err_t BluetoothConnection::read_characteristic(uint16_t handle) {
   return this->check_and_log_error_("esp_ble_gattc_read_char", err);
 }
 
-esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const std::string &data, bool response) {
+esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const uint8_t *data, size_t length,
+                                                    bool response) {
   if (!this->connected()) {
     this->log_gatt_not_connected_("write", "characteristic");
     return ESP_GATT_NOT_CONNECTED;
@@ -522,8 +523,11 @@ esp_err_t BluetoothConnection::write_characteristic(uint16_t handle, const std::
   ESP_LOGV(TAG, "[%d] [%s] Writing GATT characteristic handle %d", this->connection_index_, this->address_str_.c_str(),
            handle);
 
+  // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
+  // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
+  // const_cast is safe here and was previously hidden by a C-style cast
   esp_err_t err =
-      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, data.size(), (uint8_t *) data.data(),
+      esp_ble_gattc_write_char(this->gattc_if_, this->conn_id_, handle, length, const_cast<uint8_t *>(data),
                                response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_write_char", err);
 }
@@ -540,7 +544,7 @@ esp_err_t BluetoothConnection::read_descriptor(uint16_t handle) {
   return this->check_and_log_error_("esp_ble_gattc_read_char_descr", err);
 }
 
-esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const std::string &data, bool response) {
+esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const uint8_t *data, size_t length, bool response) {
   if (!this->connected()) {
     this->log_gatt_not_connected_("write", "descriptor");
     return ESP_GATT_NOT_CONNECTED;
@@ -548,8 +552,11 @@ esp_err_t BluetoothConnection::write_descriptor(uint16_t handle, const std::stri
   ESP_LOGV(TAG, "[%d] [%s] Writing GATT descriptor handle %d", this->connection_index_, this->address_str_.c_str(),
            handle);
 
+  // ESP-IDF's API requires a non-const uint8_t* but it doesn't modify the data
+  // The BTC layer immediately copies the data to its own buffer (see btc_gattc.c)
+  // const_cast is safe here and was previously hidden by a C-style cast
   esp_err_t err = esp_ble_gattc_write_char_descr(
-      this->gattc_if_, this->conn_id_, handle, data.size(), (uint8_t *) data.data(),
+      this->gattc_if_, this->conn_id_, handle, length, const_cast<uint8_t *>(data),
       response ? ESP_GATT_WRITE_TYPE_RSP : ESP_GATT_WRITE_TYPE_NO_RSP, ESP_GATT_AUTH_REQ_NONE);
   return this->check_and_log_error_("esp_ble_gattc_write_char_descr", err);
 }

esphome/components/bluetooth_proxy/bluetooth_connection.h

@@ -18,9 +18,9 @@ class BluetoothConnection final : public esp32_ble_client::BLEClientBase {
   esp32_ble_tracker::AdvertisementParserType get_advertisement_parser_type() override;
 
   esp_err_t read_characteristic(uint16_t handle);
-  esp_err_t write_characteristic(uint16_t handle, const std::string &data, bool response);
+  esp_err_t write_characteristic(uint16_t handle, const uint8_t *data, size_t length, bool response);
   esp_err_t read_descriptor(uint16_t handle);
-  esp_err_t write_descriptor(uint16_t handle, const std::string &data, bool response);
+  esp_err_t write_descriptor(uint16_t handle, const uint8_t *data, size_t length, bool response);
 
   esp_err_t notify_characteristic(uint16_t handle, bool enable);
 

esphome/components/bluetooth_proxy/bluetooth_proxy.cpp

@@ -305,7 +305,7 @@ void BluetoothProxy::bluetooth_gatt_write(const api::BluetoothGATTWriteRequest &
     return;
   }
 
-  auto err = connection->write_characteristic(msg.handle, msg.data, msg.response);
+  auto err = connection->write_characteristic(msg.handle, msg.data, msg.data_len, msg.response);
   if (err != ESP_OK) {
     this->send_gatt_error(msg.address, msg.handle, err);
   }
@@ -331,7 +331,7 @@ void BluetoothProxy::bluetooth_gatt_write_descriptor(const api::BluetoothGATTWri
     return;
   }
 
-  auto err = connection->write_descriptor(msg.handle, msg.data, true);
+  auto err = connection->write_descriptor(msg.handle, msg.data, msg.data_len, true);
   if (err != ESP_OK) {
     this->send_gatt_error(msg.address, msg.handle, err);
   }

esphome/components/camera_encoder/__init__.py

@@ -2,7 +2,6 @@ import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_component
 import esphome.config_validation as cv
 from esphome.const import CONF_BUFFER_SIZE, CONF_ID, CONF_TYPE
-from esphome.core import CORE
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@DT-art1"]
@@ -51,9 +50,8 @@ async def to_code(config: ConfigType) -> None:
     buffer = cg.new_Pvariable(config[CONF_ENCODER_BUFFER_ID])
     cg.add(buffer.set_buffer_size(config[CONF_BUFFER_SIZE]))
     if config[CONF_TYPE] == ESP32_CAMERA_ENCODER:
-        if CORE.using_esp_idf:
-            add_idf_component(name="espressif/esp32-camera", ref="2.1.0")
-        cg.add_build_flag("-DUSE_ESP32_CAMERA_JPEG_ENCODER")
+        add_idf_component(name="espressif/esp32-camera", ref="2.1.1")
+        cg.add_define("USE_ESP32_CAMERA_JPEG_ENCODER")
         var = cg.new_Pvariable(
             config[CONF_ID],
             config[CONF_QUALITY],

esphome/components/camera_encoder/esp32_camera_jpeg_encoder.cpp

@@ -1,3 +1,5 @@
+#include "esphome/core/defines.h"
+
 #ifdef USE_ESP32_CAMERA_JPEG_ENCODER
 
 #include "esp32_camera_jpeg_encoder.h"
@@ -15,7 +17,7 @@ camera::EncoderError ESP32CameraJPEGEncoder::encode_pixels(camera::CameraImageSp
   this->bytes_written_ = 0;
   this->out_of_output_memory_ = false;
   bool success = fmt2jpg_cb(pixels->get_data_buffer(), pixels->get_data_length(), spec->width, spec->height,
-                            to_internal_(spec->format), this->quality_, callback_, this);
+                            to_internal_(spec->format), this->quality_, callback, this);
 
   if (!success)
     return camera::ENCODER_ERROR_CONFIGURATION;
@@ -49,7 +51,7 @@ void ESP32CameraJPEGEncoder::dump_config() {
                 this->output_->get_max_size(), this->quality_, this->buffer_expand_size_);
 }
 
-size_t ESP32CameraJPEGEncoder::callback_(void *arg, size_t index, const void *data, size_t len) {
+size_t ESP32CameraJPEGEncoder::callback(void *arg, size_t index, const void *data, size_t len) {
   ESP32CameraJPEGEncoder *that = reinterpret_cast<ESP32CameraJPEGEncoder *>(arg);
   uint8_t *buffer = that->output_->get_data();
   size_t buffer_length = that->output_->get_max_size();