fix(addon): bound Core-relayed Supervisor failures too

The first bound sat in _supervisor_rest_failure, which only the direct
REST transport passes through. A standard install routes through
_supervisor_api_call_via_core, whose failed WebSocket result is returned
unchanged, so Supervisor text relayed by Core still reached the model
unbounded.

Move the bound to _raise_supervisor_api_failure, the single point every
non-retryable failure of either transport passes, and cover the Core
route with a regression test.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: Patch76

src/ha_mcp/tools/tools_addons.py

@@ -284,9 +284,7 @@ def _supervisor_rest_failure(
     response_data: dict[str, Any] | None = None,
 ) -> dict[str, Any]:
     """Normalize direct REST failure and retain 4xx/5xx status metadata."""
-    # ``error`` is built from the Supervisor payload, so it is only as bounded
-    # as whatever Supervisor sent; it reaches the model as the tool error.
-    error_text = _bounded_supervisor_text(str(error))
+    error_text = str(error)
     result: dict[str, Any] = {"success": False, "error": error_text}
     if response.is_error:
         result["_status_code"] = response.status_code
@@ -564,7 +562,12 @@ def _raise_supervisor_api_failure(
     endpoint: str,
 ) -> NoReturn:
     """Raise the structured exception represented by a non-retryable result."""
-    error_text = str(result.get("error", f"Supervisor API call failed: {endpoint}"))
+    # Both transports land here, and both carry Supervisor's own text: the
+    # direct REST payload and the message Core relays over the WebSocket
+    # bridge. Bind the size once, where every failure passes.
+    error_text = _bounded_supervisor_text(
+        str(result.get("error", f"Supervisor API call failed: {endpoint}"))
+    )
     status_code = result.get("_status_code")
     response_data = result.get("_response_data")
     if status_code == 401:

tests/src/unit/test_tools_addons.py

@@ -4623,6 +4623,30 @@ async def test_addon_mode_invalid_json_error_caps_response_body(self, monkeypatc
             "x" * (50 * 1024 - len(suffix)) + suffix
         )
 
+    @pytest.mark.asyncio
+    async def test_core_routed_failure_message_is_capped(self, monkeypatch):
+        """A Core-relayed Supervisor failure cannot produce an unbounded error."""
+        from ha_mcp.tools.tools_addons import _supervisor_api_call
+
+        monkeypatch.delenv("SUPERVISOR_TOKEN", raising=False)
+        client = _make_mock_client()
+        client.send_websocket_message = AsyncMock(
+            return_value={
+                "success": False,
+                "error": "Command failed: " + "w" * (50 * 1024 + 1),
+            }
+        )
+
+        with pytest.raises(ToolError) as exc_info:
+            await _supervisor_api_call(client, "/addons")
+
+        payload = _parse_tool_error(exc_info)
+        suffix = "\n[Supervisor response truncated to 50 KiB]"
+        message = payload["error"]["message"]
+        assert message.startswith("Command failed: w")
+        assert message.endswith(suffix)
+        assert len(message) == 50 * 1024
+
     @pytest.mark.asyncio
     async def test_addon_mode_non_object_json_caps_error_message(self, monkeypatch):
         """A valid-JSON non-object body cannot produce an unbounded tool error."""
@@ -4656,7 +4680,7 @@ async def test_addon_mode_non_object_json_caps_error_message(self, monkeypatch):
         suffix = "\n[Supervisor response truncated to 50 KiB]"
         assert message.startswith(prefix)
         assert message.endswith(suffix)
-        assert len(message) == len("Command failed: ") + 50 * 1024
+        assert len(message) == 50 * 1024
 
     @pytest.mark.asyncio
     async def test_addon_mode_error_payload_message_is_capped(self, monkeypatch):
@@ -4687,9 +4711,13 @@ async def test_addon_mode_error_payload_message_is_capped(self, monkeypatch):
 
         payload = _parse_tool_error(exc_info)
         suffix = "\n[Supervisor response truncated to 50 KiB]"
-        assert payload["error"]["message"] == (
-            "Command failed: " + "y" * (50 * 1024 - len(suffix)) + suffix
-        )
+        message = payload["error"]["message"]
+        # The status-code path prefixes the bounded Supervisor text, so the
+        # constant framing sits outside the bound.
+        prefix = "Command failed: "
+        assert message.startswith(prefix + "y")
+        assert message.endswith(suffix)
+        assert len(message.removeprefix(prefix)) == 50 * 1024
 
     @pytest.mark.asyncio
     async def test_addon_mode_non_mapping_result_payload_is_capped(self, monkeypatch):