fix: correct Tools-tab group master + LLM API toggle rendering (#1859)

* fix: show settings-UI group master toggle as on for all-mandatory groups

The per-group master switch in the Tools tab derived its checked state
from `anyEnabled`, computed only over *toggleable* tools (non-mandatory,
non-env-pinned, non-feature-gated). For a group whose tools are all
mandatory — e.g. Search & Discovery (ha_search, ha_get_overview,
ha_get_state) — that set is empty, so `anyEnabled` was always false and
the switch rendered unchecked+disabled: it read as "the whole group is
off" while the count beside it said "3/3 enabled" and the tools cannot be
disabled at all.

Compute the checked state from the group's real enabled status
(`groupEnabled`) when there are no toggleable tools, keeping the existing
`anyEnabled` bulk semantics for the interactive case. An all-mandatory
group now shows on+disabled; a mixed group keeps its interactive master.

Add JSDOM regression tests covering all-mandatory, all-disabled
toggleable, and mixed groups.

* fix: hide LLM API tool toggle on non-embedded install methods

The per-tool "LLM API" toggle offers a tool to Home Assistant
conversation agents through the LLM API surface that the ha_mcp_tools
custom component registers. That surface only exists on the in-process
(embedded) custom-component server; on the add-on, Docker, and
standalone servers nothing consumes it, so the toggle was a no-op there
yet still rendered for every tool.

The /api/settings/tools response now reports `llm_api_available`
(= is_embedded()), and the Tools tab renders the LLM API toggle column
only when it is true — other install methods drop the column entirely.

Add JSDOM coverage (toggle hidden when the flag is absent) and a
server-side test that the flag is true under HA_MCP_EMBEDDED.

* fix: group master switch reflects fully-enabled state, not any-enabled

The non-toggleable branch of the group master switch used
`groupEnabled > 0` ("any tool enabled") while the intended invariant is
"fully enabled, matching the N/N count". They diverge for a fully-locked
group that is only partially enabled — reachable via DISABLED_TOOLS or
feature gating (e.g. a mandatory tool beside an env-pinned-off one): the
switch rendered checked while the count read "1/2 enabled", the same
contradiction this PR fixes, inverted. Use `groupEnabled === tools.length`
— identical for every uniform case (all-mandatory, all-env-pinned) and
correct for the mixed case.

Also tidy the surrounding change:
- Extract the LLM API toggle fragment into an `llmToggleHtml` const,
  matching the gatedNote/envPinnedNote/readOnlyNote idiom in render().
- Drop a duplicated comment and stray RST backticks on llmApiAvailable.
- Add regression tests: a partially-enabled locked group (unchecked,
  fails on `> 0`) and an all-env-pinned-on group (checked); assert the
  hidden-LLM test against `llm_api_available: False` and the absent key.

---------

Co-authored-by: kingpanther13 <kingpanther13@users.noreply.github.com>

Author: kingpanther13

src/ha_mcp/settings_ui/__init__.py

@@ -1446,6 +1446,12 @@ async def _get_tools(_: Request) -> JSONResponse:
                 "read_only_exempt": sorted(READ_ONLY_EXEMPT_TOOLS),
                 "llm_api": llm_effective,
                 "llm_api_overrides": llm_overrides,
+                # LLM API exposure is registered by the ha_mcp_tools custom
+                # component (in-process/embedded server). On the add-on,
+                # Docker, or standalone server nothing consumes it, so the UI
+                # hides the per-tool "LLM API" toggle rather than showing a
+                # no-op control.
+                "llm_api_available": is_embedded(),
             }
         )
 

src/ha_mcp/settings_ui/settings.js

@@ -33,6 +33,12 @@ let toolEnvPinned = {};
 // never flipped keep tracking their defaults across releases.
 let toolLlm = {};
 let toolLlmOverrides = {};
+// True only on the in-process custom-component (embedded) server, which
+// registers the LLM API exposure surface. On the add-on / Docker / standalone
+// server nothing consumes it, so the per-tool "LLM API" toggle is hidden
+// rather than shown as a no-op. Set from data.llm_api_available (see
+// settings_ui/__init__.py).
+let llmApiAvailable = false;
 let saveTimer = null;
 let openGroups = new Set();
 
@@ -169,6 +175,7 @@ async function loadTools() {
   toolEnvPinned = data.env_pinned || {};
   toolLlm = data.llm_api || {};
   toolLlmOverrides = data.llm_api_overrides || {};
+  llmApiAvailable = !!data.llm_api_available;
   READ_ONLY_EXEMPT = new Set(data.read_only_exempt || []);
   // Load policy state before the first render so the "security gated"
   // toggle reflects current policy.rules. loadPolicyState() never throws
@@ -598,6 +605,19 @@ function render() {
       return MANDATORY.includes(t.name) || (!t.disabled_by && s !== 'disabled');
     }).length;
 
+    // Master-switch checked state. Normally it mirrors "any toggleable tool
+    // enabled" — it is a bulk control over the tools the user can actually
+    // flip. But when a group has NO toggleable tools (all mandatory /
+    // env-pinned / feature-gated), the switch is disabled and purely reflects
+    // status: show it ON only when the group is FULLY enabled (every tool on),
+    // matching the "N/N enabled" count. anyEnabled can't be reused here — it is
+    // always false over an empty toggleable set. So an all-mandatory group
+    // (e.g. Search & Discovery) reads as ON, while a partially-enabled locked
+    // group (e.g. a mandatory tool beside an env-pinned-off one) reads as OFF
+    // rather than contradicting its own "1/N enabled" count.
+    const masterChecked =
+      toggleable.length === 0 ? groupEnabled === tools.length : anyEnabled;
+
     const header = document.createElement('div');
     header.className = 'group-header';
     header.innerHTML = `<div class="group-header-left">` +
@@ -606,7 +626,7 @@ function render() {
       `<span class="group-count">${groupEnabled}/${tools.length} enabled</span>` +
       `</div>` +
       `<label class="switch group-master" title="Enable/disable all tools in this group">` +
-        `<input type="checkbox" name="tool-group:${escapeHtml(tag)}" ${anyEnabled ? 'checked' : ''} ${toggleable.length === 0 ? 'disabled' : ''}>` +
+        `<input type="checkbox" name="tool-group:${escapeHtml(tag)}" ${masterChecked ? 'checked' : ''} ${toggleable.length === 0 ? 'disabled' : ''}>` +
         `<span class="slider"></span>` +
       `</label>`;
 
@@ -717,6 +737,19 @@ function render() {
         : (roExemptActive
           ? '<div class="feature-locked-note">Read Only Mode: write operations of this tool are blocked; read operations stay available.</div>'
           : '');
+      // LLM API exposure column — rendered only on the embedded custom-component
+      // server (see llmApiAvailable); dropped elsewhere rather than shown as a
+      // no-op. Built here as a fragment, matching the *Note consts above.
+      const llmToggleHtml = llmApiAvailable
+        ? `<div class="toggle-group ${isEnabled ? '' : 'disabled-toggle'}" ` +
+             `title="Offer this tool to Home Assistant conversation agents through the LLM API. Applies on the agent's next message - no restart. A tool disabled above is unavailable to agents regardless.">` +
+          `<label class="switch"><input type="checkbox" name="tool:${escapeHtml(t.name)}:llm" data-tool="${escapeHtml(t.name)}" data-field="llm" ` +
+            `aria-label="${escapeHtml(title)} exposed to the conversation-agent LLM API" ` +
+            `${(toolLlm[t.name] !== false) ? 'checked' : ''} ${isEnabled ? '' : 'disabled'}>` +
+            `<span class="slider"></span></label>` +
+          `<span>LLM API</span>` +
+        `</div>`
+        : '';
 
       div.innerHTML = `<div class="tool-info">` +
         `<div class="tool-name">${escapeHtml(title)}${badges}</div>` +
@@ -750,14 +783,7 @@ function render() {
               `<span class="slider"></span></label>` +
             `<span>security gated</span>` +
           `</div>` +
-          `<div class="toggle-group ${isEnabled ? '' : 'disabled-toggle'}" ` +
-               `title="Offer this tool to Home Assistant conversation agents through the LLM API. Applies on the agent's next message - no restart. A tool disabled above is unavailable to agents regardless.">` +
-            `<label class="switch"><input type="checkbox" name="tool:${escapeHtml(t.name)}:llm" data-tool="${escapeHtml(t.name)}" data-field="llm" ` +
-              `aria-label="${escapeHtml(title)} exposed to the conversation-agent LLM API" ` +
-              `${(toolLlm[t.name] !== false) ? 'checked' : ''} ${isEnabled ? '' : 'disabled'}>` +
-              `<span class="slider"></span></label>` +
-            `<span>LLM API</span>` +
-          `</div>` +
+          llmToggleHtml +
         `</div>`;
 
       const inputs = div.querySelectorAll('input[type="checkbox"]');

tests/src/unit/test_settings_ui.py

@@ -2577,6 +2577,47 @@ async def test_get_tools_llm_api_map_and_stub_beta_default(
         assert body["llm_api"]["ha_get_state"] is False
         # The stub renders hidden-by-default (feature-gated == beta).
         assert body["llm_api"]["ha_config_set_yaml"] is False
+        # Not the in-process custom-component server: the UI hides the LLM API
+        # toggle (nothing consumes the exposure on this install method).
+        assert body["llm_api_available"] is False
+        get_data_dir.cache_clear()
+        _reset_global_settings()
+
+    @pytest.mark.asyncio
+    async def test_get_tools_llm_api_available_true_when_embedded(
+        self, monkeypatch, tmp_path
+    ):
+        """On the in-process custom-component (embedded) server the tools
+        payload advertises ``llm_api_available: True`` so the UI renders the
+        per-tool LLM API toggle."""
+        monkeypatch.setenv("HA_MCP_CONFIG_DIR", str(tmp_path))
+        monkeypatch.setenv("HA_MCP_EMBEDDED", "1")
+        from ha_mcp.utils.data_paths import get_data_dir
+
+        get_data_dir.cache_clear()
+        from ha_mcp import settings_ui as sui
+        from ha_mcp.config import _reset_global_settings
+
+        _reset_global_settings()
+        monkeypatch.setattr(
+            sui,
+            "load_tool_metadata_cache",
+            lambda: [
+                {
+                    "name": "ha_get_state",
+                    "title": "Get State",
+                    "primary_tag": "Entity",
+                    "tags": ["Entity"],
+                    "description": "x",
+                    "category": "read",
+                },
+            ],
+        )
+        handlers = sui.build_settings_handlers(server=None)
+        resp = await handlers["get_tools"](MagicMock())
+        body = json.loads(resp.body)
+
+        assert body["llm_api_available"] is True
         get_data_dir.cache_clear()
         _reset_global_settings()