esphome 2025.4.1__py3-none-any.whl → 2025.5.0b2__py3-none-any.whl

esphome/components/udp/udp_component.h

@@ -1,13 +1,8 @@
 #pragma once
 
-#include "esphome/core/component.h"
+#include "esphome/core/defines.h"
+#ifdef USE_NETWORK
 #include "esphome/components/network/ip_address.h"
-#ifdef USE_SENSOR
-#include "esphome/components/sensor/sensor.h"
-#endif
-#ifdef USE_BINARY_SENSOR
-#include "esphome/components/binary_sensor/binary_sensor.h"
-#endif
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
 #include "esphome/components/socket/socket.h"
 #endif
@@ -15,116 +10,35 @@
 #include <WiFiUdp.h>
 #endif
 #include <vector>
-#include <map>
 
 namespace esphome {
 namespace udp {
 
-struct Provider {
-  std::vector<uint8_t> encryption_key;
-  const char *name;
-  uint32_t last_code[2];
-};
-
-#ifdef USE_SENSOR
-struct Sensor {
-  sensor::Sensor *sensor;
-  const char *id;
-  bool updated;
-};
-#endif
-#ifdef USE_BINARY_SENSOR
-struct BinarySensor {
-  binary_sensor::BinarySensor *sensor;
-  const char *id;
-  bool updated;
-};
-#endif
-
-class UDPComponent : public PollingComponent {
+static const size_t MAX_PACKET_SIZE = 508;
+class UDPComponent : public Component {
  public:
-  void setup() override;
-  void loop() override;
-  void update() override;
-  void dump_config() override;
-
-#ifdef USE_SENSOR
-  void add_sensor(const char *id, sensor::Sensor *sensor) {
-    Sensor st{sensor, id, true};
-    this->sensors_.push_back(st);
-  }
-  void add_remote_sensor(const char *hostname, const char *remote_id, sensor::Sensor *sensor) {
-    this->add_provider(hostname);
-    this->remote_sensors_[hostname][remote_id] = sensor;
-  }
-#endif
-#ifdef USE_BINARY_SENSOR
-  void add_binary_sensor(const char *id, binary_sensor::BinarySensor *sensor) {
-    BinarySensor st{sensor, id, true};
-    this->binary_sensors_.push_back(st);
-  }
-
-  void add_remote_binary_sensor(const char *hostname, const char *remote_id, binary_sensor::BinarySensor *sensor) {
-    this->add_provider(hostname);
-    this->remote_binary_sensors_[hostname][remote_id] = sensor;
-  }
-#endif
   void add_address(const char *addr) { this->addresses_.emplace_back(addr); }
-#ifdef USE_NETWORK
   void set_listen_address(const char *listen_addr) { this->listen_address_ = network::IPAddress(listen_addr); }
-#endif
-  void set_port(uint16_t port) { this->port_ = port; }
-  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; }
-
-  void add_provider(const char *hostname) {
-    if (this->providers_.count(hostname) == 0) {
-      Provider provider;
-      provider.encryption_key = std::vector<uint8_t>{};
-      provider.last_code[0] = 0;
-      provider.last_code[1] = 0;
-      provider.name = hostname;
-      this->providers_[hostname] = provider;
-#ifdef USE_SENSOR
-      this->remote_sensors_[hostname] = std::map<std::string, sensor::Sensor *>();
-#endif
-#ifdef USE_BINARY_SENSOR
-      this->remote_binary_sensors_[hostname] = std::map<std::string, binary_sensor::BinarySensor *>();
-#endif
-    }
-  }
-
-  void set_encryption_key(std::vector<uint8_t> key) { this->encryption_key_ = std::move(key); }
-  void set_rolling_code_enable(bool enable) { this->rolling_code_enable_ = enable; }
-  void set_ping_pong_enable(bool enable) { this->ping_pong_enable_ = enable; }
-  void set_ping_pong_recycle_time(uint32_t recycle_time) { this->ping_pong_recyle_time_ = recycle_time; }
-  void set_provider_encryption(const char *name, std::vector<uint8_t> key) {
-    this->providers_[name].encryption_key = std::move(key);
+  void set_listen_port(uint16_t port) { this->listen_port_ = port; }
+  void set_broadcast_port(uint16_t port) { this->broadcast_port_ = port; }
+  void set_should_broadcast() { this->should_broadcast_ = true; }
+  void set_should_listen() { this->should_listen_ = true; }
+  void add_listener(std::function<void(std::vector<uint8_t> &)> &&listener) {
+    this->packet_listeners_.add(std::move(listener));
   }
+  void setup() override;
+  void loop() override;
+  void dump_config() override;
+  void send_packet(const uint8_t *data, size_t size);
+  void send_packet(const std::vector<uint8_t> &buf) { this->send_packet(buf.data(), buf.size()); }
+  float get_setup_priority() const override { return setup_priority::AFTER_WIFI; };
 
  protected:
-  void send_data_(bool all);
-  void process_(uint8_t *buf, size_t len);
-  void flush_();
-  void add_data_(uint8_t key, const char *id, float data);
-  void add_data_(uint8_t key, const char *id, uint32_t data);
-  void increment_code_();
-  void add_binary_data_(uint8_t key, const char *id, bool data);
-  void init_data_();
-
-  bool updated_{};
-  uint16_t port_{18511};
-  uint32_t ping_key_{};
-  uint32_t rolling_code_[2]{};
-  bool rolling_code_enable_{};
-  bool ping_pong_enable_{};
-  uint32_t ping_pong_recyle_time_{};
-  uint32_t last_key_time_{};
-  bool resend_ping_key_{};
-  bool resend_data_{};
-  bool should_send_{};
-  const char *name_{};
+  uint16_t listen_port_{};
+  uint16_t broadcast_port_{};
+  bool should_broadcast_{};
   bool should_listen_{};
-  ESPPreferenceObject pref_;
+  CallbackManager<void(std::vector<uint8_t> &)> packet_listeners_{};
 
 #if defined(USE_SOCKET_IMPL_BSD_SOCKETS) || defined(USE_SOCKET_IMPL_LWIP_SOCKETS)
   std::unique_ptr<socket::Socket> broadcast_socket_ = nullptr;
@@ -135,32 +49,11 @@ class UDPComponent : public PollingComponent {
   std::vector<IPAddress> ipaddrs_{};
   WiFiUDP udp_client_{};
 #endif
-  std::vector<uint8_t> encryption_key_{};
   std::vector<std::string> addresses_{};
 
-#ifdef USE_SENSOR
-  std::vector<Sensor> sensors_{};
-  std::map<std::string, std::map<std::string, sensor::Sensor *>> remote_sensors_{};
-#endif
-#ifdef USE_BINARY_SENSOR
-  std::vector<BinarySensor> binary_sensors_{};
-  std::map<std::string, std::map<std::string, binary_sensor::BinarySensor *>> remote_binary_sensors_{};
-#endif
-#ifdef USE_NETWORK
   optional<network::IPAddress> listen_address_{};
-#endif
-  std::map<std::string, Provider> providers_{};
-  std::vector<uint8_t> ping_header_{};
-  std::vector<uint8_t> header_{};
-  std::vector<uint8_t> data_{};
-  std::map<const char *, uint32_t> ping_keys_{};
-  void add_key_(const char *name, uint32_t key);
-  void send_ping_pong_request_();
-  void send_packet_(void *data, size_t len);
-  void process_ping_request_(const char *name, uint8_t *ptr, size_t len);
-
-  inline bool is_encrypted_() { return !this->encryption_key_.empty(); }
 };
 
 }  // namespace udp
 }  // namespace esphome
+#endif

esphome/components/update/__init__.py

@@ -6,6 +6,7 @@ from esphome.const import (
     CONF_DEVICE_CLASS,
     CONF_ENTITY_CATEGORY,
     CONF_FORCE_UPDATE,
+    CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
     CONF_WEB_SERVER,
@@ -14,6 +15,7 @@ from esphome.const import (
     ENTITY_CATEGORY_CONFIG,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 CODEOWNERS = ["@jesserockz"]
@@ -38,7 +40,7 @@ DEVICE_CLASSES = [
 
 CONF_ON_UPDATE_AVAILABLE = "on_update_available"
 
-UPDATE_SCHEMA = (
+_UPDATE_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -56,6 +58,34 @@ UPDATE_SCHEMA = (
 )
 
 
+def update_schema(
+    class_: MockObjClass = cv.UNDEFINED,
+    *,
+    icon: str = cv.UNDEFINED,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_ICON, icon, cv.icon),
+        (CONF_DEVICE_CLASS, device_class, cv.one_of(*DEVICE_CLASSES, lower=True)),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _UPDATE_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+UPDATE_SCHEMA = update_schema()
+UPDATE_SCHEMA.add_extra(cv.deprecated_schema_constant("update"))
+
+
 async def setup_update_core_(var, config):
     await setup_entity(var, config)
 

esphome/components/uponor_smatrix/climate/__init__.py

@@ -1,7 +1,5 @@
 import esphome.codegen as cg
 from esphome.components import climate
-import esphome.config_validation as cv
-from esphome.const import CONF_ID
 
 from .. import (
     UPONOR_SMATRIX_DEVICE_SCHEMA,
@@ -19,15 +17,12 @@ UponorSmatrixClimate = uponor_smatrix_ns.class_(
     UponorSmatrixDevice,
 )
 
-CONFIG_SCHEMA = climate.CLIMATE_SCHEMA.extend(
-    {
-        cv.GenerateID(): cv.declare_id(UponorSmatrixClimate),
-    }
-).extend(UPONOR_SMATRIX_DEVICE_SCHEMA)
+CONFIG_SCHEMA = climate.climate_schema(UponorSmatrixClimate).extend(
+    UPONOR_SMATRIX_DEVICE_SCHEMA
+)
 
 
 async def to_code(config):
-    var = cg.new_Pvariable(config[CONF_ID])
+    var = await climate.new_climate(config)
     await cg.register_component(var, config)
-    await climate.register_climate(var, config)
     await register_uponor_smatrix_device(var, config)

esphome/components/uptime/text_sensor/__init__.py

@@ -1,19 +1,59 @@
 import esphome.codegen as cg
 from esphome.components import text_sensor
 import esphome.config_validation as cv
-from esphome.const import ENTITY_CATEGORY_DIAGNOSTIC, ICON_TIMER
+from esphome.const import (
+    CONF_FORMAT,
+    CONF_HOURS,
+    CONF_ID,
+    CONF_MINUTES,
+    CONF_SECONDS,
+    ENTITY_CATEGORY_DIAGNOSTIC,
+    ICON_TIMER,
+)
 
 uptime_ns = cg.esphome_ns.namespace("uptime")
 UptimeTextSensor = uptime_ns.class_(
     "UptimeTextSensor", text_sensor.TextSensor, cg.PollingComponent
 )
-CONFIG_SCHEMA = text_sensor.text_sensor_schema(
-    UptimeTextSensor,
-    icon=ICON_TIMER,
-    entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
-).extend(cv.polling_component_schema("30s"))
+
+CONF_SEPARATOR = "separator"
+CONF_DAYS = "days"
+CONF_EXPAND = "expand"
+
+CONFIG_SCHEMA = (
+    text_sensor.text_sensor_schema(
+        UptimeTextSensor,
+        icon=ICON_TIMER,
+        entity_category=ENTITY_CATEGORY_DIAGNOSTIC,
+    )
+    .extend(
+        {
+            cv.Optional(CONF_FORMAT, default={}): cv.Schema(
+                {
+                    cv.Optional(CONF_DAYS, default="d"): cv.string_strict,
+                    cv.Optional(CONF_HOURS, default="h"): cv.string_strict,
+                    cv.Optional(CONF_MINUTES, default="m"): cv.string_strict,
+                    cv.Optional(CONF_SECONDS, default="s"): cv.string_strict,
+                    cv.Optional(CONF_SEPARATOR, default=""): cv.string_strict,
+                    cv.Optional(CONF_EXPAND, default=False): cv.boolean,
+                }
+            )
+        }
+    )
+    .extend(cv.polling_component_schema("30s"))
+)
 
 
 async def to_code(config):
-    var = await text_sensor.new_text_sensor(config)
+    format = config[CONF_FORMAT]
+    var = cg.new_Pvariable(
+        config[CONF_ID],
+        format[CONF_DAYS],
+        format[CONF_HOURS],
+        format[CONF_MINUTES],
+        format[CONF_SECONDS],
+        format[CONF_SEPARATOR],
+        format[CONF_EXPAND],
+    )
+    await text_sensor.register_text_sensor(var, config)
     await cg.register_component(var, config)

esphome/components/uptime/text_sensor/uptime_text_sensor.cpp

@@ -16,6 +16,11 @@ void UptimeTextSensor::setup() {
   this->update();
 }
 
+void UptimeTextSensor::insert_buffer_(std::string &buffer, const char *key, unsigned value) const {
+  buffer.insert(0, this->separator_);
+  buffer.insert(0, str_sprintf("%u%s", value, key));
+}
+
 void UptimeTextSensor::update() {
   auto now = millis();
   // get whole seconds since last update. Note that even if the millis count has overflowed between updates,
@@ -32,25 +37,25 @@ void UptimeTextSensor::update() {
     unsigned remainder = uptime % 60;
     uptime /= 60;
     if (interval < 30) {
-      buffer.insert(0, str_sprintf("%us", remainder));
-      if (uptime == 0)
+      this->insert_buffer_(buffer, this->seconds_text_, remainder);
+      if (!this->expand_ && uptime == 0)
         break;
     }
     remainder = uptime % 60;
     uptime /= 60;
     if (interval < 1800) {
-      buffer.insert(0, str_sprintf("%um", remainder));
-      if (uptime == 0)
+      this->insert_buffer_(buffer, this->minutes_text_, remainder);
+      if (!this->expand_ && uptime == 0)
         break;
     }
     remainder = uptime % 24;
     uptime /= 24;
     if (interval < 12 * 3600) {
-      buffer.insert(0, str_sprintf("%uh", remainder));
-      if (uptime == 0)
+      this->insert_buffer_(buffer, this->hours_text_, remainder);
+      if (!this->expand_ && uptime == 0)
         break;
     }
-    buffer.insert(0, str_sprintf("%ud", (unsigned) uptime));
+    this->insert_buffer_(buffer, this->days_text_, (unsigned) uptime);
     break;
   }
   this->publish_state(buffer);

esphome/components/uptime/text_sensor/uptime_text_sensor.h

@@ -10,13 +10,32 @@ namespace uptime {
 
 class UptimeTextSensor : public text_sensor::TextSensor, public PollingComponent {
  public:
+  UptimeTextSensor(const char *days_text, const char *hours_text, const char *minutes_text, const char *seconds_text,
+                   const char *separator, bool expand)
+      : days_text_(days_text),
+        hours_text_(hours_text),
+        minutes_text_(minutes_text),
+        seconds_text_(seconds_text),
+        separator_(separator),
+        expand_(expand) {}
   void update() override;
   void dump_config() override;
   void setup() override;
 
   float get_setup_priority() const override;
+  void set_days(const char *days_text) { this->days_text_ = days_text; }
+  void set_hours(const char *hours_text) { this->hours_text_ = hours_text; }
+  void set_minutes(const char *minutes_text) { this->minutes_text_ = minutes_text; }
+  void set_seconds(const char *seconds_text) { this->seconds_text_ = seconds_text; }
 
  protected:
+  void insert_buffer_(std::string &buffer, const char *key, unsigned value) const;
+  const char *days_text_;
+  const char *hours_text_;
+  const char *minutes_text_;
+  const char *seconds_text_;
+  const char *separator_;
+  bool expand_{};
   uint32_t uptime_{0};  // uptime in seconds, will overflow after 136 years
   uint32_t last_ms_{0};
 };

esphome/components/valve/__init__.py

@@ -5,6 +5,8 @@ from esphome.components import mqtt, web_server
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_DEVICE_CLASS,
+    CONF_ENTITY_CATEGORY,
+    CONF_ICON,
     CONF_ID,
     CONF_MQTT_ID,
     CONF_ON_OPEN,
@@ -20,6 +22,7 @@ from esphome.const import (
     DEVICE_CLASS_WATER,
 )
 from esphome.core import CORE, coroutine_with_priority
+from esphome.cpp_generator import MockObjClass
 from esphome.cpp_helpers import setup_entity
 
 IS_PLATFORM_COMPONENT = True
@@ -71,7 +74,7 @@ ValveClosedTrigger = valve_ns.class_(
 
 CONF_ON_CLOSED = "on_closed"
 
-VALVE_SCHEMA = (
+_VALVE_SCHEMA = (
     cv.ENTITY_BASE_SCHEMA.extend(web_server.WEBSERVER_SORTING_SCHEMA)
     .extend(cv.MQTT_COMMAND_COMPONENT_SCHEMA)
     .extend(
@@ -100,7 +103,35 @@ VALVE_SCHEMA = (
 )
 
 
-async def setup_valve_core_(var, config):
+def valve_schema(
+    class_: MockObjClass = cv.UNDEFINED,
+    *,
+    device_class: str = cv.UNDEFINED,
+    entity_category: str = cv.UNDEFINED,
+    icon: str = cv.UNDEFINED,
+) -> cv.Schema:
+    schema = {}
+
+    if class_ is not cv.UNDEFINED:
+        schema[cv.GenerateID()] = cv.declare_id(class_)
+
+    for key, default, validator in [
+        (CONF_DEVICE_CLASS, device_class, cv.one_of(*DEVICE_CLASSES, lower=True)),
+        (CONF_ENTITY_CATEGORY, entity_category, cv.entity_category),
+        (CONF_ICON, icon, cv.icon),
+    ]:
+        if default is not cv.UNDEFINED:
+            schema[cv.Optional(key, default=default)] = validator
+
+    return _VALVE_SCHEMA.extend(schema)
+
+
+# Remove before 2025.11.0
+VALVE_SCHEMA = valve_schema()
+VALVE_SCHEMA.add_extra(cv.deprecated_schema_constant("valve"))
+
+
+async def _setup_valve_core(var, config):
     await setup_entity(var, config)
 
     if device_class_config := config.get(CONF_DEVICE_CLASS):
@@ -132,7 +163,7 @@ async def register_valve(var, config):
     if not CORE.has_id(config[CONF_ID]):
         var = cg.Pvariable(config[CONF_ID], var)
     cg.add(cg.App.register_valve(var))
-    await setup_valve_core_(var, config)
+    await _setup_valve_core(var, config)
 
 
 async def new_valve(config, *args):

esphome/components/valve/automation.h

@@ -1,7 +1,7 @@
 #pragma once
 
-#include "esphome/core/component.h"
 #include "esphome/core/automation.h"
+#include "esphome/core/component.h"
 #include "valve.h"
 
 namespace esphome {
@@ -67,24 +67,6 @@ template<typename... Ts> class ControlAction : public Action<Ts...> {
   Valve *valve_;
 };
 
-template<typename... Ts> class ValvePublishAction : public Action<Ts...> {
- public:
-  ValvePublishAction(Valve *valve) : valve_(valve) {}
-  TEMPLATABLE_VALUE(float, position)
-  TEMPLATABLE_VALUE(ValveOperation, current_operation)
-
-  void play(Ts... x) override {
-    if (this->position_.has_value())
-      this->valve_->position = this->position_.value(x...);
-    if (this->current_operation_.has_value())
-      this->valve_->current_operation = this->current_operation_.value(x...);
-    this->valve_->publish_state();
-  }
-
- protected:
-  Valve *valve_;
-};
-
 template<typename... Ts> class ValveIsOpenCondition : public Condition<Ts...> {
  public:
   ValveIsOpenCondition(Valve *valve) : valve_(valve) {}

esphome/components/vl53l0x/sensor.py

@@ -20,6 +20,7 @@ VL53L0XSensor = vl53l0x_ns.class_(
 
 CONF_SIGNAL_RATE_LIMIT = "signal_rate_limit"
 CONF_LONG_RANGE = "long_range"
+CONF_TIMING_BUDGET = "timing_budget"
 
 
 def check_keys(obj):
@@ -54,6 +55,13 @@ CONFIG_SCHEMA = cv.All(
             cv.Optional(CONF_LONG_RANGE, default=False): cv.boolean,
             cv.Optional(CONF_TIMEOUT, default="10ms"): check_timeout,
             cv.Optional(CONF_ENABLE_PIN): pins.gpio_output_pin_schema,
+            cv.Optional(CONF_TIMING_BUDGET): cv.All(
+                cv.positive_time_period_microseconds,
+                cv.Range(
+                    min=cv.TimePeriod(microseconds=20000),
+                    max=cv.TimePeriod(microseconds=4294967295),
+                ),
+            ),
         }
     )
     .extend(cv.polling_component_schema("60s"))
@@ -73,4 +81,7 @@ async def to_code(config):
         enable = await cg.gpio_pin_expression(config[CONF_ENABLE_PIN])
         cg.add(var.set_enable_pin(enable))
 
+    if timing_budget := config.get(CONF_TIMING_BUDGET):
+        cg.add(var.set_timing_budget(timing_budget))
+
     await i2c.register_i2c_device(var, config)

esphome/components/vl53l0x/vl53l0x_sensor.cpp

@@ -28,6 +28,7 @@ void VL53L0XSensor::dump_config() {
     LOG_PIN("  Enable Pin: ", this->enable_pin_);
   }
   ESP_LOGCONFIG(TAG, "  Timeout: %u%s", this->timeout_us_, this->timeout_us_ > 0 ? "us" : " (no timeout)");
+  ESP_LOGCONFIG(TAG, "  Timing Budget %uus ", this->measurement_timing_budget_us_);
 }
 
 void VL53L0XSensor::setup() {
@@ -230,7 +231,10 @@ void VL53L0XSensor::setup() {
   reg(0x84) &= ~0x10;
   reg(0x0B) = 0x01;
 
-  measurement_timing_budget_us_ = get_measurement_timing_budget_();
+  if (this->measurement_timing_budget_us_ == 0) {
+    this->measurement_timing_budget_us_ = this->get_measurement_timing_budget_();
+  }
+
   reg(0x01) = 0xE8;
   set_measurement_timing_budget_(measurement_timing_budget_us_);
   reg(0x01) = 0x01;

esphome/components/vl53l0x/vl53l0x_sensor.h

@@ -39,6 +39,7 @@ class VL53L0XSensor : public sensor::Sensor, public PollingComponent, public i2c
   void set_long_range(bool long_range) { long_range_ = long_range; }
   void set_timeout_us(uint32_t timeout_us) { this->timeout_us_ = timeout_us; }
   void set_enable_pin(GPIOPin *enable) { this->enable_pin_ = enable; }
+  void set_timing_budget(uint32_t timing_budget) { this->measurement_timing_budget_us_ = timing_budget; }
 
  protected:
   uint32_t get_measurement_timing_budget_();
@@ -59,7 +60,7 @@ class VL53L0XSensor : public sensor::Sensor, public PollingComponent, public i2c
   float signal_rate_limit_;
   bool long_range_;
   GPIOPin *enable_pin_{nullptr};
-  uint32_t measurement_timing_budget_us_;
+  uint32_t measurement_timing_budget_us_{0};
   bool initiated_read_{false};
   bool waiting_for_interrupt_{false};
   uint8_t stop_variable_;

esphome/components/voice_assistant/__init__.py

@@ -1,7 +1,7 @@
 from esphome import automation
 from esphome.automation import register_action, register_condition
 import esphome.codegen as cg
-from esphome.components import media_player, microphone, speaker
+from esphome.components import media_player, micro_wake_word, microphone, speaker
 import esphome.config_validation as cv
 from esphome.const import (
     CONF_ID,
@@ -41,6 +41,7 @@ CONF_AUTO_GAIN = "auto_gain"
 CONF_NOISE_SUPPRESSION_LEVEL = "noise_suppression_level"
 CONF_VOLUME_MULTIPLIER = "volume_multiplier"
 
+CONF_MICRO_WAKE_WORD = "micro_wake_word"
 CONF_WAKE_WORD = "wake_word"
 
 CONF_CONVERSATION_TIMEOUT = "conversation_timeout"
@@ -88,14 +89,22 @@ CONFIG_SCHEMA = cv.All(
     cv.Schema(
         {
             cv.GenerateID(): cv.declare_id(VoiceAssistant),
-            cv.GenerateID(CONF_MICROPHONE): cv.use_id(microphone.Microphone),
-            cv.Exclusive(CONF_SPEAKER, "output"): cv.use_id(speaker.Speaker),
+            cv.Optional(
+                CONF_MICROPHONE, default={}
+            ): microphone.microphone_source_schema(
+                min_bits_per_sample=16,
+                max_bits_per_sample=16,
+                min_channels=1,
+                max_channels=1,
+            ),
             cv.Exclusive(CONF_MEDIA_PLAYER, "output"): cv.use_id(
                 media_player.MediaPlayer
             ),
+            cv.Exclusive(CONF_SPEAKER, "output"): cv.use_id(speaker.Speaker),
             cv.Optional(CONF_USE_WAKE_WORD, default=False): cv.boolean,
-            cv.Optional(CONF_VAD_THRESHOLD): cv.All(
-                cv.requires_component("esp_adf"), cv.only_with_esp_idf, cv.uint8_t
+            cv.Optional(CONF_MICRO_WAKE_WORD): cv.use_id(micro_wake_word.MicroWakeWord),
+            cv.Optional(CONF_VAD_THRESHOLD): cv.invalid(
+                "VAD threshold is no longer supported, as it requires the deprecated esp_adf external component. Use an i2s_audio microphone/speaker instead. Additionally, you may need to configure the audio_adc and audio_dac components depending on your hardware."
             ),
             cv.Optional(CONF_NOISE_SUPPRESSION_LEVEL, default=0): cv.int_range(0, 4),
             cv.Optional(CONF_AUTO_GAIN, default="0dBFS"): cv.All(
@@ -163,22 +172,39 @@ CONFIG_SCHEMA = cv.All(
     tts_stream_validate,
 )
 
+FINAL_VALIDATE_SCHEMA = cv.All(
+    cv.Schema(
+        {
+            cv.Optional(
+                CONF_MICROPHONE
+            ): microphone.final_validate_microphone_source_schema(
+                "voice_assistant", sample_rate=16000
+            ),
+        },
+        extra=cv.ALLOW_EXTRA,
+    ),
+)
+
 
 async def to_code(config):
     var = cg.new_Pvariable(config[CONF_ID])
     await cg.register_component(var, config)
 
-    mic = await cg.get_variable(config[CONF_MICROPHONE])
-    cg.add(var.set_microphone(mic))
+    mic_source = await microphone.microphone_source_to_code(config[CONF_MICROPHONE])
+    cg.add(var.set_microphone_source(mic_source))
 
-    if CONF_SPEAKER in config:
-        spkr = await cg.get_variable(config[CONF_SPEAKER])
-        cg.add(var.set_speaker(spkr))
+    if CONF_MICRO_WAKE_WORD in config:
+        mww = await cg.get_variable(config[CONF_MICRO_WAKE_WORD])
+        cg.add(var.set_micro_wake_word(mww))
 
     if CONF_MEDIA_PLAYER in config:
         mp = await cg.get_variable(config[CONF_MEDIA_PLAYER])
         cg.add(var.set_media_player(mp))
 
+    if CONF_SPEAKER in config:
+        spkr = await cg.get_variable(config[CONF_SPEAKER])
+        cg.add(var.set_speaker(spkr))
+
     cg.add(var.set_use_wake_word(config[CONF_USE_WAKE_WORD]))
 
     if (vad_threshold := config.get(CONF_VAD_THRESHOLD)) is not None: