fix(flows): keep unnamed fields when editing an existing config entry

An options, reconfigure or subentry-reconfigure step arrives pre-filled by
Home Assistant's add_suggested_values_to_schema, and saving the UI form posts
every box back. The flow walker submitted only the keys the caller named, so
voluptuous filled each omitted vol.Optional(k, default=STATIC) with its static
default and dropped every no-default optional outright: a one-field patch
through ha_set_integration(entry_id=..., config=...) silently reset the rest of
the entry. Repro on core workday, where config={"days_offset": 3} reset the
workday/exclude lists and wiped province, returning success with no warnings.

Thread keep_current_values through the two flow walkers and the form-step
consumption. Under it, a declared field the caller named no key for is
submitted with the value the step itself carries (suggestion, else a
constant's only legal value), including leaves inside sections the caller
never named, since the section is a box on the same form. A bare "default"
still means omission, exactly as it does for the UI's own form. An explicit
null is the opposite request and is honoured as a clear: consumed, then left
out of the payload. Backfilled values are the step's data, so they neither
count towards the "consumed at least one caller key" guard nor satisfy
reconfigure's "consumed EVERY key" one, and a value carrying a redaction
sentinel is never written back.

The flag is set by update_config_entry_options (ha_set_integration options
mode and helper updates), the official reconfigure flow, and the subentry
reconfigure branch. Create flows - add integration, create helper, create
subentry - are unchanged: there is no stored value to preserve and
materializing a field would invent data.

Fixes #2254

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_012d29UJTiH4Uy2Pm37SBPtr

Author: kingpanther13

src/ha_mcp/tools/config_entry_flow.py

@@ -168,8 +168,10 @@ async def set_config_subentry(
 
     The reconfigure branch fails when the flow leaves any supplied config key
     unconsumed, where it previously returned success plus a warning — see
-    :func:`_handle_config_subentry_flow_steps` for why. The create branch is
-    unchanged.
+    :func:`_handle_config_subentry_flow_steps` for why. It also walks with
+    ``keep_current_values`` (issue #2254), so a partial patch keeps the
+    subentry fields it does not name instead of resetting them. The create
+    branch is unchanged on both counts.
     """
     _reject_redaction_sentinels(config_dict)
     flow_result = await client.start_config_subentry_flow(
@@ -205,6 +207,7 @@ async def set_config_subentry(
             flow_result,
             config_dict,
             is_reconfigure=subentry_id is not None,
+            keep_current_values=subentry_id is not None,
         )
     except asyncio.CancelledError:
         await _abort_subentry_flow_best_effort(client, flow_id)
@@ -289,6 +292,15 @@ async def update_config_entry_options(
     ``ha_set_integration`` path passes ``None`` to accept any domain). Starts
     an options flow, walks the flow steps, and returns the result. Aborts the
     flow on error. ``noun`` only affects response wording.
+
+    This edits an existing entry, so the walk runs with
+    ``keep_current_values``: every field an options step declares that
+    ``config_dict`` does not name is submitted with the value the step itself
+    carries, exactly as the HA UI's "Configure" dialog posts back the boxes
+    nobody touched. Before issue #2254 those keys were dropped and voluptuous
+    substituted each field's static default, so a one-key patch silently reset
+    the rest of the entry's options. A key the caller sets to ``None`` is the
+    opposite request and is honoured as a clear.
     """
     _reject_redaction_sentinels(config_dict)
     config_entry = await client.get_config_entry(entry_id)
@@ -332,6 +344,7 @@ async def update_config_entry_options(
             config_dict,
             submit_fn=client.submit_options_flow_step,
             helper_type=expected_domain,
+            keep_current_values=True,
         )
     except Exception:
         try:

src/ha_mcp/tools/config_entry_flow_form.py

@@ -4,8 +4,11 @@
 entry points) when that module crossed the ~1000-line split threshold. Turns a
 step's serialized ``data_schema`` plus the caller's config dict into the payload
 to submit, and tracks what was consumed so a later step redeclaring a field can
-be filled. Imports the menu selection keys from ``config_entry_flow_menu``
-(never submitted as form data); ``config_entry_flow_walker`` imports from here.
+be filled. Flows that edit an existing object pass ``keep_current_values``,
+so a field the caller left out goes back as the step presented it instead of
+being dropped (issue #2254). Imports the menu selection keys from
+``config_entry_flow_menu`` (never submitted as form data);
+``config_entry_flow_walker`` imports from here.
 """
 
 import copy
@@ -15,6 +18,7 @@
 from typing import Any
 
 from ..errors import ErrorCode, create_error_response
+from ..redaction import carries_sentinel
 from .config_entry_flow_menu import _MENU_SELECTION_KEY_ORDER
 from .helpers import raise_tool_error
 
@@ -245,6 +249,7 @@ def _consume_section_schema(
     *,
     allow_reuse: bool = True,
     explicit_source: bool = False,
+    keep_current_values: bool = False,
 ) -> dict[str, Any]:
     """Consume config values for a nested flow section.
 
@@ -272,6 +277,7 @@ def _consume_section_schema(
                 reuse_state,
                 allow_reuse=allow_reuse,
                 explicit_source=True,
+                keep_current_values=keep_current_values,
             )
         )
         _record_ignored_section_keys(
@@ -290,6 +296,7 @@ def _consume_section_schema(
             reuse_state,
             allow_reuse=allow_reuse,
             explicit_source=explicit_source,
+            keep_current_values=keep_current_values,
         )
     )
     return nested_data
@@ -363,12 +370,45 @@ def _step_owned_submission_value(field: dict[str, Any]) -> Any:
     return _MISSING_DEFAULT
 
 
+def _is_redacted_value(value: Any) -> bool:
+    """True when a step-owned value is, or contains, a redaction sentinel.
+
+    ``redact_secrets`` rewrites a deep copy of a schema for error contexts, so
+    the live step a walk submits against should never carry a sentinel.
+    Backfill is the one place that turns schema data back into submitted data,
+    though, so the check is made anyway: writing ``<redacted: set>`` into a
+    password field would replace a working secret with a placeholder.
+    """
+    if isinstance(value, list):
+        return any(carries_sentinel(item) for item in value)
+    return carries_sentinel(value)
+
+
+def _current_value_backfill(field: dict[str, Any]) -> tuple[Any, bool]:
+    """Resubmit what an edit-mode step carries for a field the caller left out.
+
+    Options, reconfigure and subentry-reconfigure steps arrive pre-filled by
+    Home Assistant's ``add_suggested_values_to_schema``, and the UI's save
+    posts every box back, so a field nobody named has to be submitted as the
+    step presented it or the save rewrites it (issue #2254). Returns
+    ``_NO_SUBMISSION`` when the step supplies no value of its own: a bare
+    ``"default"`` is the static schema value, which voluptuous fills in for an
+    omitted key exactly as it does for the UI's own form.
+    """
+    step_owned = _step_owned_submission_value(field)
+    if step_owned is _MISSING_DEFAULT or _is_redacted_value(step_owned):
+        return _NO_SUBMISSION
+    return step_owned, False
+
+
 def _redeclared_field_submission(
     field: dict[str, Any],
     name: str,
     path_prefix: str,
     reuse_state: _ReuseState | None,
     allow_reuse: bool,
+    *,
+    keep_current_values: bool = False,
 ) -> tuple[Any, bool]:
     """Decide what to submit for a declared field the caller named no key for here.
 
@@ -378,9 +418,13 @@ def _redeclared_field_submission(
     and the caller's value for this step outranks anything injected. Otherwise,
     in order:
 
-    1. The field is not required: omit it. Nothing is ever injected into an
-       optional field, or into a section that is neither required nor named by
-       the caller (``allow_reuse``) — materializing either would invent data.
+    1. The field is not required, or reuse is barred for this site because the
+       caller named neither it nor the section holding it (``allow_reuse``).
+       Under ``keep_current_values`` the step's own value still goes back, per
+       :func:`_current_value_backfill` — it is the step's data, not the
+       caller's, so barring reuse does not bar it, and a section the backfill
+       itself materializes has to carry what it requires. Otherwise omit:
+       injecting into either on a create flow would invent data.
     2. The step's own schema supplies a value — a suggestion or a constant's
        only legal value, per :func:`_step_owned_submission_value`: submit that.
        It is schema data rather than a caller key, so it is neither marked
@@ -397,17 +441,20 @@ def _redeclared_field_submission(
        spend the one write allowed per (step, path).
 
     Mutates ``reuse_state`` on the fourth branch. Menu selection keys never
-    reach here. Motivating regression (issue #2057): an options flow —
-    LocalTuya's — that declares the same field on an early step and again on a
-    later one.
+    reach here. Motivating regressions: issue #2057, an options flow
+    (LocalTuya's) that declares the same field on an early step and again on a
+    later one; issue #2254, a one-field options patch that reset every field
+    the caller did not name back to its static schema default.
     """
-    if reuse_state is None or not allow_reuse:
+    if reuse_state is None:
         return _NO_SUBMISSION
     dotted = _section_path(path_prefix, name)
     if dotted in reuse_state.filled:
         return _NO_SUBMISSION
-    if not field.get("required"):
-        return _NO_SUBMISSION
+    if not allow_reuse or not field.get("required"):
+        if not keep_current_values:
+            return _NO_SUBMISSION
+        return _current_value_backfill(field)
     step_owned = _step_owned_submission_value(field)
     if step_owned is not _MISSING_DEFAULT:
         return step_owned, False
@@ -432,6 +479,7 @@ def _consume_leaf_field(
     *,
     allow_reuse: bool = True,
     explicit_source: bool = False,
+    keep_current_values: bool = False,
 ) -> None:
     """Fill ``name`` in ``form_data`` from the caller's config or from the step itself.
 
@@ -441,17 +489,30 @@ def _consume_leaf_field(
     the flat caller dict. With no key to pop,
     :func:`_redeclared_field_submission` chooses between omitting the field,
     submitting the step's own value, and resubmitting the recorded one.
+
+    Under ``keep_current_values`` an explicit ``None`` on a non-required field
+    is a clear rather than a value: the key is consumed and recorded, but left
+    out of the payload, because omission is how the UI's form clears a box
+    (issue #2254). A required field keeps submitting ``None`` verbatim — Home
+    Assistant, not this walker, decides what a required null means.
     """
     if name in remaining_config:
         value = remaining_config.pop(name)
-        form_data[name] = value
+        clearing = keep_current_values and value is None and not field.get("required")
+        if not clearing:
+            form_data[name] = value
         _mark_consumed(consumed_config_keys, path_prefix, name)
         if reuse_state is not None:
             reuse_state.record(path_prefix, name, value, scoped_only=explicit_source)
         return
 
     value, from_caller = _redeclared_field_submission(
-        field, name, path_prefix, reuse_state, allow_reuse
+        field,
+        name,
+        path_prefix,
+        reuse_state,
+        allow_reuse,
+        keep_current_values=keep_current_values,
     )
     if value is _MISSING_DEFAULT:
         return
@@ -471,6 +532,7 @@ def _consume_declared_section(
     *,
     allow_reuse: bool,
     explicit_source: bool,
+    keep_current_values: bool,
 ) -> None:
     """Merge one section field's data into ``form_data``.
 
@@ -501,6 +563,7 @@ def _consume_declared_section(
         allow_reuse=allow_reuse
         and (bool(field.get("required")) or explicit_section is not None),
         explicit_source=explicit_source,
+        keep_current_values=keep_current_values,
     )
     if not nested_data:
         return
@@ -520,6 +583,7 @@ def _consume_form_schema(
     *,
     allow_reuse: bool = True,
     explicit_source: bool = False,
+    keep_current_values: bool = False,
 ) -> dict[str, Any]:
     """Consume matching config values and shape nested flow sections.
 
@@ -528,7 +592,8 @@ def _consume_form_schema(
     Unknown keys inside explicit section dicts are added to
     ``ignored_config_keys`` with their dotted section path. A declared field the
     caller named no key for is filled per
-    :func:`_redeclared_field_submission`.
+    :func:`_redeclared_field_submission`, which ``keep_current_values`` puts
+    into the edit-mode contract described there.
     """
     form_data: dict[str, Any] = {}
 
@@ -548,6 +613,7 @@ def _consume_form_schema(
                 reuse_state,
                 allow_reuse=allow_reuse,
                 explicit_source=explicit_source,
+                keep_current_values=keep_current_values,
             )
             continue
 
@@ -562,6 +628,7 @@ def _consume_form_schema(
                 path_prefix,
                 allow_reuse=allow_reuse,
                 explicit_source=explicit_source,
+                keep_current_values=keep_current_values,
             )
 
     return form_data
@@ -636,6 +703,8 @@ def _handle_form_step(
     ignored_config_keys: set[str] | None = None,
     consumed_config_keys: set[str] | None = None,
     reuse_state: _ReuseState | None = None,
+    *,
+    keep_current_values: bool = False,
 ) -> dict[str, Any]:
     """Validate a form step and return form data to submit.
 
@@ -654,6 +723,15 @@ def _handle_form_step(
     warning. Nothing is injected into an optional field, or into a section
     neither marked required nor named by the caller.
 
+    ``keep_current_values`` switches that last sentence off for the flows that
+    edit an existing object — options, reconfigure, subentry reconfigure. Their
+    steps arrive pre-filled with the stored values and the UI's save posts all
+    of them back, so a declared field the caller left out is submitted with the
+    step's own value wherever the step supplies one (issue #2254); a field the
+    caller set to ``None`` is instead consumed and omitted, which is the UI's
+    clear gesture. It takes a ``reuse_state`` to work: the record is what keeps
+    a backfill off a path the caller already filled in this same step.
+
     When ``data_schema`` is absent (HA didn't tell us field names), falls
     back to legacy behaviour: submit all non-menu keys and clear them. This
     keeps single-step flows working when HA omits the schema.
@@ -691,4 +769,5 @@ def _handle_form_step(
         consumed_config_keys,
         "",
         reuse_state,
+        keep_current_values=keep_current_values,
     )

src/ha_mcp/tools/config_entry_flow_walker.py

@@ -685,12 +685,14 @@ def _flow_form_payload(
     remaining_config: dict[str, Any],
     ignored_config_keys: set[str],
     reuse_state: _ReuseState,
+    keep_current_values: bool,
 ) -> tuple[dict[str, Any], bool]:
     """Build one generic flow form payload.
 
     Returns the payload and whether the step consumed at least one caller key
     — not which ones; ``remaining_config`` and ``ignored_config_keys`` carry
-    that.
+    that. A value the step backfills under ``keep_current_values`` is the
+    step's own data, so it never counts as a consumed caller key.
     """
     consumed_form_keys: set[str] = set()
     form_data = _auto_confirm_form_payload(current_step)
@@ -702,6 +704,7 @@ def _flow_form_payload(
             ignored_config_keys,
             consumed_form_keys,
             reuse_state,
+            keep_current_values=keep_current_values,
         )
     return form_data, bool(consumed_form_keys)
 
@@ -757,6 +760,7 @@ async def _handle_flow_steps(
     helper_type: str | None = None,
     *,
     is_reconfigure: bool = False,
+    keep_current_values: bool = False,
 ) -> dict[str, Any]:
     """Walk a multi-step config flow handling menu and form steps.
 
@@ -793,6 +797,18 @@ async def _handle_flow_steps(
             the caller can react. Under ``is_reconfigure`` no schema is
             fetched (the live step already carries the right one) and the
             value is used only to name the integration in error prose.
+        keep_current_values: Whether this flow edits an existing object
+            (options, reconfigure, subentry reconfigure) rather than creating
+            one. Its steps arrive pre-filled with the stored values and the HA
+            UI's save posts every box back, so a declared field the caller
+            named no key for is submitted with the step's own value instead of
+            being dropped — which is what stopped a one-field options patch
+            from resetting everything it did not mention (issue #2254). A
+            field the caller explicitly set to ``None`` is consumed and
+            omitted instead: omission is the UI's clear gesture. Backfilled
+            values are the step's data, so they neither count towards the
+            "consumed at least one caller key" test below nor satisfy the
+            reconfigure "consumed EVERY key" one.
         is_reconfigure: Whether this is the official reconfigure flow — the
             same mode HA uses for reauth, so both ``reconfigure_successful``
             and ``reauth_successful`` count as its success aborts. In this
@@ -893,6 +909,7 @@ async def _handle_flow_steps(
                 remaining_config=remaining_config,
                 ignored_config_keys=ignored_config_keys,
                 reuse_state=reuse_state,
+                keep_current_values=keep_current_values,
             )
             if consumed_any:
                 any_form_key_consumed = True
@@ -1040,6 +1057,7 @@ async def _handle_config_subentry_flow_steps(
     config: dict[str, Any],
     *,
     is_reconfigure: bool,
+    keep_current_values: bool = False,
 ) -> dict[str, Any]:
     """Walk a config subentry flow and accept HA's reconfigure-success abort.
 
@@ -1057,6 +1075,11 @@ async def _handle_config_subentry_flow_steps(
     read as "done" to an agent. This is a behaviour change for
     ``ha_config_set_helper(helper_type="config_subentry", subentry_id=...)``
     callers who previously relied on the warning.
+
+    ``keep_current_values`` carries the same edit-mode contract as in
+    :func:`_handle_flow_steps` (issue #2254): reconfiguring a subentry
+    resubmits the step's own value for every declared field the caller named
+    no key for, so a partial patch stops wiping the rest of the subentry.
     """
     remaining_config = dict(config)
     current_step = initial_step
@@ -1124,6 +1147,7 @@ async def _handle_config_subentry_flow_steps(
                 remaining_config,
                 ignored_config_keys,
                 reuse_state=reuse_state,
+                keep_current_values=keep_current_values,
             )
             logger.debug(
                 "Config subentry flow step %s: form submit (step_id=%s, keys=%s)",