Merge remote-tracking branch 'upstream/master' into feat/issue-863-stdio-settings

# Conflicts:
#	tests/src/e2e/haos_only/test_manage_addon_modes.py

Author: kingpanther13

README.md

@@ -353,6 +353,13 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file
 - **[@w3z315](https://github.com/w3z315)** — Financial support via [GitHub Sponsors](https://github.com/sponsors/julienld). Thank you! ☕
 - **[@griffinmartin](https://github.com/griffinmartin)** — Added OpenCode (by Anomaly) as a selectable AI client in the setup wizard, with both stdio and streamable HTTP support.
 - **[@hhopke](https://github.com/hhopke)** — Fixed addon API calls to route through HA Core ingress proxy instead of direct container connections, fixing `ha_manage_addon` proxy mode on addon installs.
+- **[@tomwilkie](https://github.com/tomwilkie)** — JMESPath middleware exploration (#1147) whose review-time token-measurement data informed the design of #1199 and #1225.
+- **[@SealKan](https://github.com/SealKan)** — `fields=`/`attribute_keys=` projection on six read-heavy tools (#1225), `ha_call_event` tool (#1239), and dashboards-list helper refactor (#1207).
+- **[@KarelTestSpecial](https://github.com/KarelTestSpecial)** — Cached YAML instance to prevent CPU spikes during bulk edits (#1371).
+- **[@corgan2222](https://github.com/corgan2222)** — HA brand assets for custom integration (#1317).
+- **[@drseanwing](https://github.com/drseanwing)** — Progress emission via FastMCP `Context` in long-running tools (#1124); tool-discovery / categorized-search docs (#1123).
+- **[@fnordpig](https://github.com/fnordpig)** — Config subentry support (#1393) and Assist pipeline management tool (#1392).
+- **[@paul43210](https://github.com/paul43210)** — `array_patch` mode in `ha_manage_addon` for atomic GET-modify-POST (#1063).
 
 ---
 

custom_components/ha_mcp_tools/yaml_rt.py

@@ -74,7 +74,21 @@ def _register_ha_tags() -> None:
 _register_ha_tags()
 
 
-_THREAD_LOCAL = threading.local()
+def _build_yaml() -> YAML:
+    """Create a fresh round-trip YAML instance with HA tag support."""
+    ry = YAML(typ="rt")
+    ry.preserve_quotes = True
+    return ry
+
+
+class _YAMLStorage(threading.local):
+    """Thread-local storage for ruamel.yaml instances."""
+
+    def __init__(self) -> None:
+        self.yaml = _build_yaml()
+
+
+_STORAGE = _YAMLStorage()
 
 
 def make_yaml() -> YAML:
@@ -87,11 +101,11 @@ def make_yaml() -> YAML:
     Thread-local storage is used because ruamel.yaml instances are not
     thread-safe.
     """
-    if not hasattr(_THREAD_LOCAL, "yaml"):
-        ry = YAML(typ="rt")
-        ry.preserve_quotes = True
-        _THREAD_LOCAL.yaml = ry
-    return _THREAD_LOCAL.yaml
+    try:
+        return _STORAGE.yaml
+    except AttributeError:
+        _STORAGE.yaml = _build_yaml()
+        return _STORAGE.yaml
 
 
 def yaml_dumps(ry: YAML, data: Any) -> str:

tests/src/e2e/haos_only/test_manage_addon_modes.py

@@ -46,22 +46,25 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import time
 from typing import Any
 
 import pytest
 
 from ..utilities.assertions import parse_mcp_result, safe_call_tool
+from ..utilities.wait_helpers import _POLLING_TRANSIENT_ERRORS
+
+logger = logging.getLogger(__name__)
 
 pytestmark = [pytest.mark.haos_only]
 
-# Node-RED's container takes 20–60s after install to leave "startup" and
-# enter "started". Any test whose contract requires the addon to actually
-# answer HTTP (i.e. asserts on ``status_code`` rather than tolerating a
-# structured error) must wait for it; otherwise CI flakes whenever the
-# runner is slow enough that the addon isn't ready by test-call time.
-# The bake installs Node-RED with ``start=True`` (build_image.py ADDONS),
-# so we only need to wait — never to start it ourselves.
+# Tests that assert strictly on ``status_code`` (with no fall-back error
+# branch) need the addon's container to have reached Supervisor's
+# ``started`` state — the bake installs every addon with ``start=True``,
+# but the container can take tens of seconds to leave its transient boot
+# phase, which is enough to flake the strict assertion. Timeout sized
+# for cache-cold runners; 2s poll matches sibling lifecycle helpers.
 _ADDON_RUNNING_TIMEOUT_S = 120.0
 _ADDON_RUNNING_POLL_S = 2.0
 
@@ -109,31 +112,34 @@ async def _wait_addon_running(
 
     Use this before any test that asserts on the HTTP/WS contract of an
     addon (rather than tolerating an addon-not-running structured
-    error). ``ha_manage_addon`` short-circuits with
-    ``{"success": False, "error": {...}, "state": "startup"}`` when
-    Supervisor reports the addon as anything other than ``started``;
-    the bake installs addons with ``start=True`` but their containers
-    can take 20-60s to leave the ``startup`` phase, which is enough to
-    flake any strict-shape assertion. Mirrors the
-    ``wait_for_entity_registered`` discipline already mandated by
-    AGENTS.md for tests that act on freshly created entities.
-
-    Transient ``ToolError`` from ``ha_get_addon`` (e.g. a momentary
-    Supervisor 5xx during boot) is treated as "not ready yet" and the
-    poll continues until the outer timeout. The deadline still fires;
-    transient errors can't mask a wedged addon forever.
+    error). When Supervisor reports the addon as anything other than
+    ``started``, ``ha_manage_addon`` raises ``ToolError`` from its
+    running-state guard (``tools_addons.py`` "Verify add-on is running");
+    the JSON-encoded error payload carries the observed transient state.
+    The bake installs addons with ``start=True``, but their containers
+    can take tens of seconds to reach ``started`` — long enough to
+    flake any strict-shape assertion on the proxy path. Mirrors
+    ``_wait_for_state`` in ``test_addon_lifecycle.py`` (same private-
+    sibling convention as ``_resolve_slug``).
+
+    Transient errors from ``ha_get_addon`` are caught via the project's
+    canonical ``_POLLING_TRANSIENT_ERRORS`` tuple (see
+    ``tests/src/e2e/utilities/wait_helpers.py``) — the same discipline
+    every other polling helper in the suite uses. Bugs (``TypeError`` /
+    ``AttributeError`` / ``KeyError`` / ``AssertionError``) propagate.
+    The deadline still fires; transient errors can't mask a wedged
+    addon forever.
     """
-    from fastmcp.exceptions import ToolError
-
     deadline = time.monotonic() + timeout
     last_state: str | None = None
     while True:
         try:
             detail_raw = await mcp_client.call_tool("ha_get_addon", {"slug": slug})
             detail = parse_mcp_result(detail_raw).get("addon") or {}
             last_state = detail.get("state")
-        except ToolError as e:
-            last_state = f"<ToolError: {e!s}[:60]>"
+        except _POLLING_TRANSIENT_ERRORS as e:
+            logger.debug(f"⚠️ Transient error polling addon {slug!r}: {e}")
+            last_state = f"<transient: {str(e)[:60]}>"
         if last_state == "started":
             return
         if time.monotonic() >= deadline:

tests/src/unit/test_yaml_rt_singleton.py

@@ -4,10 +4,10 @@
 
 import sys
 import threading
-from unittest.mock import MagicMock, patch
+from io import StringIO
+from unittest.mock import MagicMock
 
 import pytest
-from ruamel.yaml import YAML
 
 # Mock Home Assistant imports so the package __init__ can be loaded.
 sys.modules["voluptuous"] = MagicMock()
@@ -22,31 +22,31 @@
 )
 
 from custom_components.ha_mcp_tools.yaml_rt import (  # noqa: E402
-    _THREAD_LOCAL,
+    _STORAGE,
     make_yaml,
 )
 
 
 @pytest.fixture(autouse=True)
 def clear_thread_local():
     """Ensure the thread-local storage is clean before each test."""
-    if hasattr(_THREAD_LOCAL, "yaml"):
-        del _THREAD_LOCAL.yaml
+    if hasattr(_STORAGE, "yaml"):
+        del _STORAGE.yaml
     yield
-    if hasattr(_THREAD_LOCAL, "yaml"):
-        del _THREAD_LOCAL.yaml
+    if hasattr(_STORAGE, "yaml"):
+        del _STORAGE.yaml
 
 
 def test_make_yaml_singleton_in_same_thread():
     """Verify that make_yaml returns the same instance when called multiple times in one thread."""
-    # We patch YAML constructor to count instantiations.
-    # Since YAML is a class, we patch its __init__.
-    with patch.object(YAML, "__init__", return_value=None) as mock_init:
-        y1 = make_yaml()
-        y2 = make_yaml()
+    y1 = make_yaml()
+    y2 = make_yaml()
 
-        assert y1 is y2
-        assert mock_init.call_count == 1
+    assert y1 is y2
+    # Round-trip a quoted scalar to confirm preserve_quotes is set
+    buf = StringIO()
+    y1.dump({"key": '"quoted_value"'}, buf)
+    assert '"quoted_value"' in buf.getvalue()
 
 
 def test_make_yaml_singleton_per_thread():
@@ -56,17 +56,28 @@ def test_make_yaml_singleton_per_thread():
     def worker(name):
         instances[name] = make_yaml()
 
-    with patch.object(YAML, "__init__", return_value=None) as mock_init:
-        t1 = threading.Thread(target=worker, args=("t1",))
-        t2 = threading.Thread(target=worker, args=("t2",))
+    t1 = threading.Thread(target=worker, args=("t1",))
+    t2 = threading.Thread(target=worker, args=("t2",))
 
-        t1.start()
-        t1.join()
-        t2.start()
-        t2.join()
+    t1.start()
+    t1.join()
+    t2.start()
+    t2.join()
 
-        assert "t1" in instances
-        assert "t2" in instances
-        assert instances["t1"] is not instances["t2"]
-        # One instantiation per thread
-        assert mock_init.call_count == 2
+    assert "t1" in instances
+    assert "t2" in instances
+    assert instances["t1"] is not instances["t2"]
+
+
+def test_make_yaml_rebuilds_after_storage_cleared():
+    """Verify that make_yaml rebuilds the instance after thread-local storage is cleared."""
+    y1 = make_yaml()
+    del _STORAGE.yaml
+    y2 = make_yaml()
+
+    assert y2 is not y1
+    assert y2.preserve_quotes is True
+    # Round-trip a quoted scalar to confirm preserve_quotes actually took effect
+    buf = StringIO()
+    y2.dump({"key": '"quoted_value"'}, buf)
+    assert '"quoted_value"' in buf.getvalue()