@orellbuehler/homeassistant-mcp 0.1.0 → 0.3.0

package/README.md

@@ -1,14 +1,20 @@
 # homeassistant-mcp
 
+[![npm](https://img.shields.io/npm/v/@orellbuehler/homeassistant-mcp.svg)](https://www.npmjs.com/package/@orellbuehler/homeassistant-mcp)
+[![CI](https://github.com/OrellBuehler/homeassistant-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/OrellBuehler/homeassistant-mcp/actions/workflows/ci.yml)
+[![node](https://img.shields.io/node/v/@orellbuehler/homeassistant-mcp.svg)](https://nodejs.org)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
+
 MCP server for [Home Assistant](https://www.home-assistant.io/) that exposes the
 [REST API](https://www.home-assistant.io/integrations/api/) and WebSocket registries as tools for
 AI agents.
 
 It is built to **help an agent author and validate Home Assistant configuration and automations** —
 not to control your home. It tells the agent what exists live (entities, services, events, areas,
-devices), validates the agent's work (render Jinja2 templates, check config, read the error log), and
-can reload reloadable domains after YAML edits. It deliberately has **no tools to turn devices on/off,
-set states, or fire events**.
+devices), validates the agent's work (render Jinja2 templates, check config, read the error log),
+can reload reloadable domains after YAML edits, and can configure the Energy dashboard (sources and
+the Individual-devices list). It deliberately has **no tools to turn devices on/off, set states, or
+fire events**.
 
 ## Install
 
@@ -23,7 +29,9 @@ claude mcp add homeassistant \
   -- npx -y @orellbuehler/homeassistant-mcp
 ```
 
-See [Usage with Claude Code](#usage-with-claude-code) for the equivalent JSON config.
+See [Usage with Claude Code](#usage-with-claude-code) for the equivalent JSON config. For any other
+MCP client, run the package directly — `npx -y @orellbuehler/homeassistant-mcp` with `HASS_URL` and
+`HASS_TOKEN` set in the environment. Requires Node.js 20+.
 
 ## Getting a token
 
@@ -122,12 +130,44 @@ available immediately. Verify with `claude mcp list` (should show `homeassistant
 `list_entities` (REST) shows entities that currently have state; `list_registry_entities`
 (WebSocket) shows everything registered, including disabled entities, with area/device grouping.
 
+**Energy dashboard** (WebSocket)
+
+| Tool                      | Description                                                                         |
+| ------------------------- | ----------------------------------------------------------------------------------- |
+| `get_energy_prefs`        | Current Energy dashboard preferences (sources + the Individual-devices list).       |
+| `save_energy_prefs`       | Overwrite preferences (read-modify-write; replaces each provided key).              |
+| `add_energy_devices`      | Append entities to Individual devices, deduped, with optional eligibility warnings. |
+| `remove_energy_devices`   | Remove entities from Individual devices by `stat_consumption`.                      |
+| `validate_energy_prefs`   | Run `energy/validate` and correlate issues with each entity/source.                 |
+| `set_energy_grid_source`  | Set the single grid source (import/export plus optional cost/price stats).          |
+| `set_energy_solar_source` | Add or update a solar production source (upsert by `stat_energy_from`).             |
+
+The Energy dashboard config lives in `.storage/energy` and is only reachable over WebSocket (not
+REST). The write tools (`save_energy_prefs`, `add_`/`remove_energy_devices`, `set_energy_*`) call
+`energy/save_prefs`, which **requires an admin token**. They are read-modify-write (fetch the current
+prefs, then save), so editing the Energy dashboard in the HA UI at the same moment can be overwritten
+— this is fine for the intended single-agent use.
+
+**Traces** (WebSocket, read-only)
+
+| Tool                 | Description                                                                         |
+| -------------------- | ----------------------------------------------------------------------------------- |
+| `list_traces`        | Recent execution traces (newest first) for an `automation.*`/`script.*` entity.     |
+| `get_trace`          | Full step-by-step trace for one run (config, variables, context, error).            |
+| `get_trace_contexts` | Map context ids to the trace run that produced them (causality across automations). |
+
+Pass an `automation.*` or `script.*` entity id; the trace key is resolved automatically. Use these
+to debug **whether and how** an automation you authored actually ran.
+
 ## Safety boundary
 
 - **No device control.** There is no generic `call_service`, no `set_state`, and no `fire_event`.
   The server cannot turn things on/off.
 - **`reload` is restricted** to a fixed allowlist of `*.reload` / `homeassistant.reload_*` services.
   It restarts reloadable domains (e.g. re-reads `automations.yaml`) but cannot control devices.
+- **Energy dashboard config is writable** via `energy/save_prefs` (the `*_energy_*` tools). This is
+  configuration authoring — the dashboard's sources and Individual-devices list — not device control,
+  and it needs an admin token. No `call_service`, `set_state`, or `fire_event` is added.
 - **Read tools expose your home's data** (entity names, states, areas) to the agent/LLM. Use a
   scoped HA user if that matters to you.
 - Prefer `https` and a trusted network path to your instance.

package/dist/hass/rest.js

@@ -1,9 +1,11 @@
 export class HassClient {
     baseUrl;
     token;
-    constructor(baseUrl, token) {
+    timeoutMs;
+    constructor(baseUrl, token, timeoutMs = 15000) {
         this.baseUrl = baseUrl.replace(/\/+$/, "");
         this.token = token;
+        this.timeoutMs = timeoutMs;
     }
     headers(options) {
         return {
@@ -12,15 +14,29 @@ export class HassClient {
             ...(options.headers ?? {}),
         };
     }
-    async fetch(path, options = {}) {
-        const res = await fetch(`${this.baseUrl}${path}`, {
-            ...options,
-            headers: this.headers(options),
-        });
+    async request(path, options) {
+        let res;
+        try {
+            res = await fetch(`${this.baseUrl}${path}`, {
+                ...options,
+                headers: this.headers(options),
+                signal: options.signal ?? AbortSignal.timeout(this.timeoutMs),
+            });
+        }
+        catch (e) {
+            if (e instanceof DOMException && e.name === "TimeoutError") {
+                throw new Error(`Home Assistant request timed out after ${this.timeoutMs}ms`, { cause: e });
+            }
+            throw e;
+        }
         if (!res.ok) {
             const body = await res.text();
             throw new Error(`${res.status} ${res.statusText}: ${body}`);
         }
+        return res;
+    }
+    async fetch(path, options = {}) {
+        const res = await this.request(path, options);
         if (res.status === 204)
             return { success: true };
         const ct = res.headers.get("content-type") ?? "";
@@ -29,14 +45,6 @@ export class HassClient {
         return res.text();
     }
     async fetchText(path, options = {}) {
-        const res = await fetch(`${this.baseUrl}${path}`, {
-            ...options,
-            headers: this.headers(options),
-        });
-        if (!res.ok) {
-            const body = await res.text();
-            throw new Error(`${res.status} ${res.statusText}: ${body}`);
-        }
-        return res.text();
+        return (await this.request(path, options)).text();
     }
 }

package/dist/hass/ws.js

@@ -56,7 +56,12 @@ export class HassWsClient {
                         finish(() => resolve(msg.result));
                     }
                     else {
-                        finish(() => reject(new Error(`Home Assistant WebSocket error: ${msg.error?.message ?? "unknown error"}`)));
+                        finish(() => {
+                            const error = new Error(`Home Assistant WebSocket error: ${msg.error?.message ?? "unknown error"}`);
+                            if (msg.error?.code)
+                                error.code = msg.error.code;
+                            reject(error);
+                        });
                     }
                 }
             });

package/dist/index.js

@@ -4,4 +4,10 @@ import { client, wsClient } from "./config.js";
 import { createServer } from "./server.js";
 const server = createServer(client, wsClient);
 const transport = new StdioServerTransport();
-await server.connect(transport);
+try {
+    await server.connect(transport);
+}
+catch (e) {
+    console.error(`Failed to start homeassistant-mcp: ${String(e)}`);
+    process.exit(1);
+}

package/dist/server.js

@@ -6,8 +6,10 @@ import { registerTemplateTools } from "./tools/templates.js";
 import { registerHistoryTools } from "./tools/history.js";
 import { registerReloadTools } from "./tools/reload.js";
 import { registerRegistryTools } from "./tools/registry.js";
+import { registerEnergyTools } from "./tools/energy.js";
+import { registerTraceTools } from "./tools/trace.js";
 export function createServer(client, wsClient) {
-    const server = new McpServer({ name: "homeassistant-mcp", version: "0.1.0" });
+    const server = new McpServer({ name: "homeassistant-mcp", version: "0.3.0" });
     registerEntityTools(server, client);
     registerServiceTools(server, client);
     registerSystemTools(server, client);
@@ -15,5 +17,7 @@ export function createServer(client, wsClient) {
     registerHistoryTools(server, client);
     registerReloadTools(server, client);
     registerRegistryTools(server, wsClient);
+    registerEnergyTools(server, wsClient, client);
+    registerTraceTools(server, wsClient, client);
     return server;
 }

package/dist/tools/energy.js

@@ -0,0 +1,235 @@
+import { z } from "zod";
+import { ok, err } from "../hass/format.js";
+const ENERGY_UNITS = new Set([
+    "Wh",
+    "kWh",
+    "MWh",
+    "GWh",
+    "TWh",
+    "mWh",
+    "J",
+    "kJ",
+    "MJ",
+    "GJ",
+    "cal",
+    "kcal",
+    "Mcal",
+    "Gcal",
+]);
+const show = (v) => (v === undefined || v === null ? "missing" : String(v));
+async function getPrefs(ws) {
+    try {
+        return (await ws.command("energy/get_prefs"));
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === "ERR_NOT_FOUND" || /no prefs/i.test(String(e))) {
+            return { energy_sources: [], device_consumption: [] };
+        }
+        throw e;
+    }
+}
+function eligibilityReasons(state, id) {
+    if (!state)
+        return [`${id} not found in current states`];
+    const a = (state.attributes ?? {});
+    const reasons = [];
+    if (a.device_class !== "energy") {
+        reasons.push(`device_class is ${show(a.device_class)} (expected energy)`);
+    }
+    if (a.state_class !== "total" && a.state_class !== "total_increasing") {
+        reasons.push(`state_class is ${show(a.state_class)} (expected total or total_increasing)`);
+    }
+    const unit = a.unit_of_measurement;
+    if (typeof unit !== "string" || !ENERGY_UNITS.has(unit)) {
+        reasons.push(`unit is ${show(unit)} (expected an energy unit such as kWh)`);
+    }
+    return reasons;
+}
+export function registerEnergyTools(server, ws, client) {
+    server.tool("get_energy_prefs", "Get the current Energy dashboard preferences (EnergyPreferences) over the WebSocket API: energy_sources (grid/solar/battery/gas/water) and the device_consumption list shown under 'Individual devices'. Returns an empty object if energy has not been configured yet.", {}, async () => {
+        try {
+            return ok(await getPrefs(ws));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("save_energy_prefs", "Overwrite Energy dashboard preferences via energy/save_prefs (requires an admin token). Each provided key (energy_sources, device_consumption, device_consumption_water) replaces that key server-side; omitted keys are left untouched. Prefer get_energy_prefs first and send back a modified object (read-modify-write). For the common cases use add_energy_devices / remove_energy_devices / set_energy_grid_source / set_energy_solar_source instead.", {
+        prefs: z
+            .object({
+            energy_sources: z.array(z.record(z.unknown())).optional(),
+            device_consumption: z.array(z.record(z.unknown())).optional(),
+            device_consumption_water: z.array(z.record(z.unknown())).optional(),
+        })
+            .describe("Partial or full EnergyPreferences object to write"),
+    }, async ({ prefs }) => {
+        try {
+            return ok(await ws.command("energy/save_prefs", prefs));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("add_energy_devices", "Append entities to the Energy dashboard 'Individual devices' list (device_consumption), deduping by stat_consumption and preserving energy_sources. Optionally warns about entities that are not valid energy statistics (need device_class energy, state_class total/total_increasing and an energy unit) but still adds them. Returns the added/skipped ids, any warnings, and the resulting device_consumption.", {
+        entity_ids: z
+            .array(z.string())
+            .describe("Entity ids to add as device_consumption stats, e.g. ['sensor.fridge_energy']"),
+        names: z
+            .array(z.string())
+            .optional()
+            .describe("Optional display names, aligned by index with entity_ids"),
+    }, async ({ entity_ids, names }) => {
+        try {
+            const prefs = await getPrefs(ws);
+            const existing = prefs.device_consumption ?? [];
+            const present = new Set(existing.map((d) => d.stat_consumption));
+            let statesById = null;
+            try {
+                const states = (await client.fetch("/api/states"));
+                statesById = new Map(states.map((s) => [s.entity_id, s]));
+            }
+            catch {
+                statesById = null;
+            }
+            const warnings = [];
+            if (statesById) {
+                for (const id of entity_ids) {
+                    const reasons = eligibilityReasons(statesById.get(id), id);
+                    if (reasons.length)
+                        warnings.push({ entity_id: id, reasons });
+                }
+            }
+            const added = [];
+            const skipped = [];
+            const next = [...existing];
+            entity_ids.forEach((id, i) => {
+                if (present.has(id)) {
+                    skipped.push(id);
+                    return;
+                }
+                present.add(id);
+                const entry = { stat_consumption: id };
+                const name = names?.[i];
+                if (name)
+                    entry.name = name;
+                next.push(entry);
+                added.push(id);
+            });
+            const updated = (await ws.command("energy/save_prefs", {
+                device_consumption: next,
+            }));
+            return ok({ added, skipped, warnings, device_consumption: updated.device_consumption });
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("remove_energy_devices", "Remove entities from the Energy dashboard 'Individual devices' list (device_consumption) by matching stat_consumption, preserving energy_sources. Returns the removed ids and the resulting device_consumption.", {
+        entity_ids: z.array(z.string()).describe("Entity ids to remove from device_consumption"),
+    }, async ({ entity_ids }) => {
+        try {
+            const prefs = await getPrefs(ws);
+            const remove = new Set(entity_ids);
+            const existing = prefs.device_consumption ?? [];
+            const removed = existing
+                .filter((d) => remove.has(d.stat_consumption))
+                .map((d) => d.stat_consumption);
+            const next = existing.filter((d) => !remove.has(d.stat_consumption));
+            const updated = (await ws.command("energy/save_prefs", {
+                device_consumption: next,
+            }));
+            return ok({ removed, device_consumption: updated.device_consumption });
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("validate_energy_prefs", "Run Home Assistant's energy/validate against the current preferences and return per-item issues. device_consumption, device_consumption_water and energy_sources issues are correlated with their stat_consumption / source so you can see which entity each issue belongs to. Includes the raw validation result.", {}, async () => {
+        try {
+            const prefs = await getPrefs(ws);
+            const result = (await ws.command("energy/validate"));
+            const device_consumption = (result.device_consumption ?? [])
+                .map((issues, i) => ({
+                stat_consumption: prefs.device_consumption?.[i]?.stat_consumption ?? null,
+                issues,
+            }))
+                .filter((d) => Array.isArray(d.issues) && d.issues.length > 0);
+            const device_consumption_water = (result.device_consumption_water ?? [])
+                .map((issues, i) => ({
+                stat_consumption: prefs.device_consumption_water?.[i]?.stat_consumption ?? null,
+                issues,
+            }))
+                .filter((d) => Array.isArray(d.issues) && d.issues.length > 0);
+            const energy_sources = (result.energy_sources ?? [])
+                .map((issues, i) => ({ source: prefs.energy_sources?.[i] ?? null, issues }))
+                .filter((s) => Array.isArray(s.issues) && s.issues.length > 0);
+            return ok({ device_consumption, device_consumption_water, energy_sources, raw: result });
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("set_energy_grid_source", "Set the single grid source of the Energy dashboard (unified model: import/export stats plus optional cost/price stats), merging onto the existing grid source (unspecified fields are kept) and preserving all other energy_sources and device_consumption. Adds a grid source if none exists; cost_adjustment_day defaults to 0. To clear a field, use save_energy_prefs.", {
+        stat_energy_from: z
+            .string()
+            .optional()
+            .describe("Statistic for energy imported from the grid"),
+        stat_energy_to: z.string().optional().describe("Statistic for energy returned to the grid"),
+        stat_cost: z.string().optional().describe("Statistic tracking import cost"),
+        entity_energy_price: z.string().optional().describe("Entity providing the import price"),
+        number_energy_price: z.number().optional().describe("Fixed import price per unit"),
+        stat_compensation: z.string().optional().describe("Statistic tracking export compensation"),
+        entity_energy_price_export: z
+            .string()
+            .optional()
+            .describe("Entity providing the export price"),
+        number_energy_price_export: z.number().optional().describe("Fixed export price per unit"),
+        cost_adjustment_day: z.number().optional().describe("Daily cost adjustment (default 0)"),
+        stat_rate: z.string().optional().describe("Statistic tracking the current grid energy rate"),
+        power_config: z
+            .object({
+            stat_rate: z.string().optional(),
+            stat_rate_inverted: z.string().optional(),
+            stat_rate_from: z.string().optional(),
+            stat_rate_to: z.string().optional(),
+        })
+            .optional()
+            .describe("Live power-flow config; provide exactly one method"),
+    }, async (args) => {
+        try {
+            const prefs = await getPrefs(ws);
+            const sources = prefs.energy_sources ?? [];
+            const idx = sources.findIndex((s) => s.type === "grid");
+            const grid = { ...(idx >= 0 ? sources[idx] : {}), ...args, type: "grid" };
+            if (grid.cost_adjustment_day === undefined || grid.cost_adjustment_day === null) {
+                grid.cost_adjustment_day = 0;
+            }
+            const next = idx >= 0 ? sources.map((s, i) => (i === idx ? grid : s)) : [...sources, grid];
+            return ok(await ws.command("energy/save_prefs", { energy_sources: next }));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("set_energy_solar_source", "Add or update a solar production source on the Energy dashboard, upserting by stat_energy_from (unspecified fields on an existing source are kept) and preserving all other energy_sources and device_consumption.", {
+        stat_energy_from: z.string().describe("Statistic for solar energy production"),
+        config_entry_solar_forecast: z
+            .array(z.string())
+            .optional()
+            .describe("Config entry ids providing a solar production forecast"),
+        stat_rate: z.string().optional().describe("Statistic tracking the current solar energy rate"),
+    }, async (args) => {
+        try {
+            const prefs = await getPrefs(ws);
+            const sources = prefs.energy_sources ?? [];
+            const idx = sources.findIndex((s) => s.type === "solar" && s.stat_energy_from === args.stat_energy_from);
+            const solar = { ...(idx >= 0 ? sources[idx] : {}), ...args, type: "solar" };
+            const next = idx >= 0 ? sources.map((s, i) => (i === idx ? solar : s)) : [...sources, solar];
+            return ok(await ws.command("energy/save_prefs", { energy_sources: next }));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+}

package/dist/tools/reload.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { ok, err } from "../hass/format.js";
-const RELOAD_TARGETS = {
+export const RELOAD_TARGETS = {
     all: { domain: "homeassistant", service: "reload_all" },
     core: { domain: "homeassistant", service: "reload_core_config" },
     automation: { domain: "automation", service: "reload" },

package/dist/tools/system.js

@@ -21,6 +21,7 @@ export function registerSystemTools(server, client) {
         lines: z
             .number()
             .int()
+            .min(0)
             .optional()
             .describe("Number of trailing lines to return (default 100; use 0 for the full log)"),
     }, async ({ lines }) => {

package/dist/tools/trace.js

@@ -0,0 +1,74 @@
+import { z } from "zod";
+import { ok, err, domainOf } from "../hass/format.js";
+async function resolveTarget(entityId, client) {
+    const domain = domainOf(entityId);
+    if (domain !== "automation" && domain !== "script") {
+        throw new Error(`Traces are only available for automation.* or script.* entities, got ${entityId}`);
+    }
+    const objectId = entityId.slice(domain.length + 1);
+    if (!objectId) {
+        throw new Error(`Invalid ${domain} entity id: ${entityId}`);
+    }
+    if (domain === "script") {
+        return { domain, item_id: objectId };
+    }
+    const state = (await client.fetch(`/api/states/${encodeURIComponent(entityId)}`));
+    const id = state.attributes?.id;
+    if (id === undefined || id === null || id === "") {
+        throw new Error(`Automation ${entityId} has no 'id' attribute, so Home Assistant stores no traces for it`);
+    }
+    return { domain, item_id: String(id) };
+}
+function startMs(t) {
+    const s = t.timestamp?.start;
+    const n = s ? Date.parse(s) : 0;
+    return Number.isNaN(n) ? 0 : n;
+}
+export function registerTraceTools(server, ws, client) {
+    server.tool("list_traces", "List recent execution traces (newest first) for an automation or script via the WebSocket trace API — to debug whether and how it ran. Each summary has run_id, state, script_execution (finished/error/aborted/cancelled/…), last_step, timestamp and any error. Use get_trace with a run_id for the full step-by-step trace.", { entity_id: z.string().describe("An automation.* or script.* entity id") }, async ({ entity_id }) => {
+        try {
+            const { domain, item_id } = await resolveTarget(entity_id, client);
+            const list = ((await ws.command("trace/list", { domain, item_id })) ??
+                []);
+            const traces = [...list]
+                .sort((a, b) => startMs(b) - startMs(a))
+                .map((t) => {
+                const row = {
+                    run_id: t.run_id,
+                    state: t.state,
+                    script_execution: t.script_execution,
+                    last_step: t.last_step,
+                    timestamp: t.timestamp,
+                };
+                if (t.error !== undefined)
+                    row.error = t.error;
+                return row;
+            });
+            return ok({ entity_id, domain, item_id, count: traces.length, traces });
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("get_trace", "Get the full execution trace for one run of an automation or script: the per-step path with each step's result, the config, variables, context and any error. Find run_id with list_traces.", {
+        entity_id: z.string().describe("An automation.* or script.* entity id"),
+        run_id: z.string().describe("Run id from list_traces"),
+    }, async ({ entity_id, run_id }) => {
+        try {
+            const { domain, item_id } = await resolveTarget(entity_id, client);
+            return ok(await ws.command("trace/get", { domain, item_id, run_id }));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+    server.tool("get_trace_contexts", "Map Home Assistant context ids to the trace run that produced them for an automation or script (trace/contexts) — useful for tracing causality, e.g. which automation run triggered another.", { entity_id: z.string().describe("An automation.* or script.* entity id") }, async ({ entity_id }) => {
+        try {
+            const { domain, item_id } = await resolveTarget(entity_id, client);
+            return ok(await ws.command("trace/contexts", { domain, item_id }));
+        }
+        catch (e) {
+            return err(e);
+        }
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orellbuehler/homeassistant-mcp",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "Model Context Protocol server for Home Assistant: introspect entities, services, events, registries, render templates and validate configuration to help AI agents author HA configs and automations.",
   "type": "module",
   "bin": {
@@ -11,7 +11,7 @@
     "!dist/__tests__"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "start": "node dist/index.js",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -19,10 +19,10 @@
     "lint": "eslint src",
     "format": "prettier --write .",
     "format:check": "prettier --check .",
-    "prepare": "npm run build"
+    "prepare": "npm run build && prek install"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=20"
   },
   "keywords": [
     "mcp",
@@ -54,6 +54,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@j178/prek": "^0.4.4",
     "@types/node": "^22.15.3",
     "@types/ws": "^8.5.12",
     "eslint": "^10.4.1",