@coffeerunhobby/mcp-ha-connect 2.2.1 → 2.4.0

package/src/tools/homeassistant/calendar.ts

@@ -1,97 +0,0 @@
-/**
- * Calendar tools - List calendars and get calendar events
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { listCalendarsSchema, getCalendarEventsSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import type { z } from 'zod';
-
-type GetCalendarEventsArgs = z.infer<typeof getCalendarEventsSchema>;
-
-export function registerListCalendarsTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'listCalendars',
-    {
-      description: 'List all calendar entities in Home Assistant. Returns calendar names and their current state.',
-      inputSchema: listCalendarsSchema,
-    },
-    wrapToolHandler('listCalendars', async () => {
-      const calendars = await client.getCalendars();
-      return toToolResult({
-        count: calendars.length,
-        calendars,
-      });
-    }, Permission.QUERY)
-  );
-}
-
-export function registerGetCalendarEventsTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getCalendarEvents',
-    {
-      description: `Get events from one or all Home Assistant calendars.
-
-Examples:
-- All calendars, next 30 days: {}
-- Specific calendar: { entity_id: "calendar.family" }
-- Next 7 days: { days: 7 }
-- Date range: { start_date: "2026-01-01", end_date: "2026-01-31" }
-- Specific calendar + date range: { entity_id: "calendar.work", start_date: "2026-02-01", days: 14 }`,
-      inputSchema: getCalendarEventsSchema,
-    },
-    wrapToolHandler('getCalendarEvents', async (args: GetCalendarEventsArgs) => {
-      // Parse dates
-      const startDate = args.start_date ? new Date(args.start_date) : new Date();
-
-      let endDate: Date;
-      if (args.days) {
-        endDate = new Date(startDate.getTime() + args.days * 24 * 60 * 60 * 1000);
-      } else if (args.end_date) {
-        endDate = new Date(args.end_date);
-      } else {
-        // Default: 30 days from start
-        endDate = new Date(startDate.getTime() + 30 * 24 * 60 * 60 * 1000);
-      }
-
-      if (args.entity_id) {
-        // Get events from specific calendar
-        const events = await client.getCalendarEvents(args.entity_id, startDate, endDate);
-        return toToolResult({
-          calendar: args.entity_id,
-          start: startDate.toISOString(),
-          end: endDate.toISOString(),
-          count: events.length,
-          events: events.map(e => ({
-            summary: e.summary,
-            start: e.start.dateTime || e.start.date,
-            end: e.end.dateTime || e.end.date,
-            description: e.description,
-            location: e.location,
-          })),
-        });
-      } else {
-        // Get events from all calendars
-        const allEvents = await client.getAllCalendarEvents(startDate, endDate);
-        const totalCount = allEvents.reduce((sum, cal) => sum + cal.events.length, 0);
-
-        return toToolResult({
-          start: startDate.toISOString(),
-          end: endDate.toISOString(),
-          total_count: totalCount,
-          calendars: allEvents.map(cal => ({
-            calendar: cal.calendar,
-            count: cal.events.length,
-            events: cal.events.map(e => ({
-              summary: e.summary,
-              start: e.start.dateTime || e.start.date,
-              end: e.end.dateTime || e.end.date,
-              description: e.description,
-              location: e.location,
-            })),
-          })),
-        });
-      }
-    }, Permission.QUERY)
-  );
-}

package/src/tools/homeassistant/callService.ts

@@ -1,25 +0,0 @@
-/**
- * callService tool - Call a Home Assistant service
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import type { ServiceCallData } from '../../types/index.js';
-import { serviceCallSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export function registerCallServiceTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'callService',
-    {
-      description: 'Call a Home Assistant service (e.g., turn on a light, set temperature).',
-      inputSchema: serviceCallSchema,
-    },
-    wrapToolHandler('callService', async (args: ServiceCallData) => {
-      if (!args.domain || !args.service) {
-        return toToolResult({ error: 'domain and service are required' }, true);
-      }
-      const result = await client.callService(args);
-      return toToolResult({ success: true, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/controlClimate.ts

@@ -1,68 +0,0 @@
-/**
- * controlClimate tool - Control climate/thermostat devices
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { controlClimateSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type ControlClimateArgs = z.infer<typeof controlClimateSchema>;
-
-export function registerControlClimateTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'controlClimate',
-    {
-      description: 'Control a climate/thermostat device with temperature and mode settings.',
-      inputSchema: controlClimateSchema,
-    },
-    wrapToolHandler('controlClimate', async (args: ControlClimateArgs) => {
-      const missing = await entityNotFoundResult(client, args.entity_id);
-      if (missing) return missing;
-      const results: unknown[] = [];
-
-      if (args.hvac_mode !== undefined) {
-        const result = await client.callService({
-          domain: 'climate',
-          service: 'set_hvac_mode',
-          target: { entity_id: args.entity_id },
-          service_data: { hvac_mode: args.hvac_mode },
-        });
-        results.push({ action: 'set_hvac_mode', hvac_mode: args.hvac_mode, context: result.context });
-      }
-
-      if (args.temperature !== undefined) {
-        const result = await client.callService({
-          domain: 'climate',
-          service: 'set_temperature',
-          target: { entity_id: args.entity_id },
-          service_data: { temperature: args.temperature },
-        });
-        results.push({ action: 'set_temperature', temperature: args.temperature, context: result.context });
-      }
-
-      if (args.fan_mode !== undefined) {
-        const result = await client.callService({
-          domain: 'climate',
-          service: 'set_fan_mode',
-          target: { entity_id: args.entity_id },
-          service_data: { fan_mode: args.fan_mode },
-        });
-        results.push({ action: 'set_fan_mode', fan_mode: args.fan_mode, context: result.context });
-      }
-
-      if (args.preset_mode !== undefined) {
-        const result = await client.callService({
-          domain: 'climate',
-          service: 'set_preset_mode',
-          target: { entity_id: args.entity_id },
-          service_data: { preset_mode: args.preset_mode },
-        });
-        results.push({ action: 'set_preset_mode', preset_mode: args.preset_mode, context: result.context });
-      }
-
-      return toToolResult({ success: true, entity_id: args.entity_id, actions: results });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/controlCover.ts

@@ -1,48 +0,0 @@
-/**
- * controlCover tool - Control covers/blinds
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { controlCoverSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type ControlCoverArgs = z.infer<typeof controlCoverSchema>;
-
-export function registerControlCoverTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'controlCover',
-    {
-      description: 'Control a cover/blind with position and tilt settings.',
-      inputSchema: controlCoverSchema,
-    },
-    wrapToolHandler('controlCover', async (args: ControlCoverArgs) => {
-      const missing = await entityNotFoundResult(client, args.entity_id);
-      if (missing) return missing;
-      const actionMap: Record<string, string> = {
-        open: 'open_cover',
-        close: 'close_cover',
-        stop: 'stop_cover',
-        set_position: 'set_cover_position',
-        set_tilt: 'set_cover_tilt_position',
-      };
-
-      const serviceData: Record<string, unknown> = {};
-      if (args.action === 'set_position' && args.position !== undefined) {
-        serviceData.position = args.position;
-      }
-      if (args.action === 'set_tilt' && args.tilt_position !== undefined) {
-        serviceData.tilt_position = args.tilt_position;
-      }
-
-      const result = await client.callService({
-        domain: 'cover',
-        service: actionMap[args.action] || args.action,
-        target: { entity_id: args.entity_id },
-        service_data: Object.keys(serviceData).length > 0 ? serviceData : undefined,
-      });
-      return toToolResult({ success: true, entity_id: args.entity_id, action: args.action, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/controlFan.ts

@@ -1,44 +0,0 @@
-/**
- * controlFan tool - Control fans
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { controlFanSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type ControlFanArgs = z.infer<typeof controlFanSchema>;
-
-export function registerControlFanTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'controlFan',
-    {
-      description: 'Control a fan with speed, oscillation, and direction settings.',
-      inputSchema: controlFanSchema,
-    },
-    wrapToolHandler('controlFan', async (args: ControlFanArgs) => {
-      const missing = await entityNotFoundResult(client, args.entity_id);
-      if (missing) return missing;
-      let service: string = args.action;
-      const serviceData: Record<string, unknown> = {};
-
-      if (args.action === 'set_speed') {
-        service = 'set_percentage';
-        if (args.percentage !== undefined) serviceData.percentage = args.percentage;
-      } else if (args.action === 'oscillate') {
-        if (args.oscillating !== undefined) serviceData.oscillating = args.oscillating;
-      } else if (args.action === 'set_direction') {
-        if (args.direction !== undefined) serviceData.direction = args.direction;
-      }
-
-      const result = await client.callService({
-        domain: 'fan',
-        service,
-        target: { entity_id: args.entity_id },
-        service_data: Object.keys(serviceData).length > 0 ? serviceData : undefined,
-      });
-      return toToolResult({ success: true, entity_id: args.entity_id, action: args.action, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/controlLight.ts

@@ -1,38 +0,0 @@
-/**
- * controlLight tool - Control lights with advanced options
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { controlLightSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type ControlLightArgs = z.infer<typeof controlLightSchema>;
-
-export function registerControlLightTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'controlLight',
-    {
-      description: 'Control a light with advanced options like brightness, color, and color temperature.',
-      inputSchema: controlLightSchema,
-    },
-    wrapToolHandler('controlLight', async (args: ControlLightArgs) => {
-      const missing = await entityNotFoundResult(client, args.entity_id);
-      if (missing) return missing;
-      const serviceData: Record<string, unknown> = {};
-      if (args.brightness_pct !== undefined) serviceData.brightness_pct = args.brightness_pct;
-      if (args.color_temp_kelvin !== undefined) serviceData.color_temp_kelvin = args.color_temp_kelvin;
-      if (args.rgb_color !== undefined) serviceData.rgb_color = args.rgb_color;
-      if (args.transition !== undefined) serviceData.transition = args.transition;
-
-      const result = await client.callService({
-        domain: 'light',
-        service: args.action,
-        target: { entity_id: args.entity_id },
-        service_data: Object.keys(serviceData).length > 0 ? serviceData : undefined,
-      });
-      return toToolResult({ success: true, entity_id: args.entity_id, action: args.action, settings: serviceData, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/controlMediaPlayer.ts

@@ -1,50 +0,0 @@
-/**
- * controlMediaPlayer tool - Control media players
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { controlMediaPlayerSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type ControlMediaPlayerArgs = z.infer<typeof controlMediaPlayerSchema>;
-
-export function registerControlMediaPlayerTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'controlMediaPlayer',
-    {
-      description: 'Control a media player with playback, volume, and media selection.',
-      inputSchema: controlMediaPlayerSchema,
-    },
-    wrapToolHandler('controlMediaPlayer', async (args: ControlMediaPlayerArgs) => {
-      const missing = await entityNotFoundResult(client, args.entity_id);
-      if (missing) return missing;
-      const actionMap: Record<string, string> = {
-        play: 'media_play',
-        pause: 'media_pause',
-        stop: 'media_stop',
-        next: 'media_next_track',
-        previous: 'media_previous_track',
-        volume_set: 'volume_set',
-        volume_mute: 'volume_mute',
-      };
-
-      const serviceData: Record<string, unknown> = {};
-      if (args.action === 'volume_set' && args.volume_level !== undefined) {
-        serviceData.volume_level = args.volume_level;
-      }
-      if (args.action === 'volume_mute' && args.is_volume_muted !== undefined) {
-        serviceData.is_volume_muted = args.is_volume_muted;
-      }
-
-      const result = await client.callService({
-        domain: 'media_player',
-        service: actionMap[args.action] || args.action,
-        target: { entity_id: args.entity_id },
-        service_data: Object.keys(serviceData).length > 0 ? serviceData : undefined,
-      });
-      return toToolResult({ success: true, entity_id: args.entity_id, action: args.action, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/createAutomation.ts

@@ -1,35 +0,0 @@
-/**
- * createAutomation tool - Create a new automation
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import type { AutomationTrigger, AutomationCondition, AutomationAction } from '../../types/index.js';
-import { createAutomationSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import type { z } from 'zod';
-
-type CreateAutomationArgs = z.infer<typeof createAutomationSchema>;
-
-export function registerCreateAutomationTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'createAutomation',
-    {
-      description: 'Create a new Home Assistant automation. Requires specifying triggers, conditions (optional), and actions.',
-      inputSchema: createAutomationSchema,
-    },
-    wrapToolHandler('createAutomation', async (args: CreateAutomationArgs) => {
-      if (!args.alias || !args.trigger || !args.action) {
-        return toToolResult({ error: 'alias, trigger, and action are required' }, true);
-      }
-      const result = await client.createAutomation({
-        alias: args.alias,
-        description: args.description,
-        mode: args.mode,
-        trigger: args.trigger as AutomationTrigger | AutomationTrigger[],
-        condition: args.condition as AutomationCondition | AutomationCondition[] | undefined,
-        action: args.action as AutomationAction | AutomationAction[],
-      });
-      return toToolResult({ success: true, automation_id: result.id, alias: args.alias, message: 'Automation created successfully' });
-    }, Permission.CONFIGURE)
-  );
-}

package/src/tools/homeassistant/deleteAutomation.ts

@@ -1,24 +0,0 @@
-/**
- * deleteAutomation tool - Delete an automation
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { automationIdSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import type { z } from 'zod';
-
-type DeleteAutomationArgs = z.infer<typeof automationIdSchema>;
-
-export function registerDeleteAutomationTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'deleteAutomation',
-    {
-      description: 'Delete a Home Assistant automation. Only works for automations created via the UI/API.',
-      inputSchema: automationIdSchema,
-    },
-    wrapToolHandler('deleteAutomation', async ({ automation_id }: DeleteAutomationArgs) => {
-      await client.deleteAutomation(automation_id);
-      return toToolResult({ success: true, automation_id, message: 'Automation deleted successfully' });
-    }, Permission.CONFIGURE)
-  );
-}

package/src/tools/homeassistant/entityAction.ts

@@ -1,35 +0,0 @@
-/**
- * entityAction tool - Simple entity actions (turn_on, turn_off, toggle)
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { entityActionSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-import { entityNotFoundResult } from './entityGuard.js';
-import type { z } from 'zod';
-
-type EntityActionArgs = z.infer<typeof entityActionSchema>;
-
-export function registerEntityActionTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'entityAction',
-    {
-      description: 'Perform a simple action on an entity (turn_on, turn_off, toggle). Automatically detects the domain.',
-      inputSchema: entityActionSchema,
-    },
-    wrapToolHandler('entityAction', async ({ entity_id, action }: EntityActionArgs) => {
-      const domain = entity_id.split('.')[0];
-      if (!domain) {
-        return toToolResult({ error: 'Invalid entity_id format', hint: 'entity_id must be in domain.name format such as light.living_room — use the searchEntities tool to discover valid entity IDs' }, true);
-      }
-      const missing = await entityNotFoundResult(client, entity_id);
-      if (missing) return missing;
-      const result = await client.callService({
-        domain,
-        service: action,
-        target: { entity_id },
-      });
-      return toToolResult({ success: true, entity_id, action, context: result.context });
-    }, Permission.CONTROL)
-  );
-}

package/src/tools/homeassistant/entityGuard.ts

@@ -1,28 +0,0 @@
-/**
- * Existence guard for entity-targeted control tools.
- *
- * Home Assistant silently ignores service calls whose target entity_id does not
- * exist: the call returns 200 with an empty change list. Without this guard the
- * tool would report `success: true` for an action that never happened, so an
- * LLM client would believe a typo'd light was switched on.
- */
-
-import type { CallToolResult } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { toToolResult } from '../common.js';
-
-/**
- * Returns an error result when `entityId` does not exist in Home Assistant,
- * or `null` when it does (the caller should then proceed with the action).
- */
-export async function entityNotFoundResult(client: HaClient, entityId: string): Promise<CallToolResult | null> {
-  const state = await client.getState(entityId);
-  if (state) {
-    return null;
-  }
-  return toToolResult({
-    error: 'Entity not found',
-    entity_id: entityId,
-    hint: 'No action was performed. Use the searchEntities tool with a keyword to find the correct entity_id',
-  }, true);
-}

package/src/tools/homeassistant/getAllSensors.ts

@@ -1,46 +0,0 @@
-/**
- * getAllSensors tool - Get all sensor entities
- * Returns paginated, lightweight entities by default to reduce response size.
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { toLightweight } from '../../types/index.js';
-import { haPaginationSchema, toToolResult, wrapToolHandler, Permission, paginateArray } from '../common.js';
-
-export function registerGetAllSensorsTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getAllSensors',
-    {
-      description: 'Get all sensor states from Home Assistant (sensor.* and binary_sensor.* entities). Returns paginated lightweight entities by default (50 per page). Use includeAttributes=true for full entity data.',
-      inputSchema: haPaginationSchema,
-    },
-    wrapToolHandler('getAllSensors', async (args) => {
-      const { page, pageSize, includeAttributes } = args;
-      const sensors = await client.getAllSensors();
-
-      if (includeAttributes) {
-        // Return full entities with all attributes
-        const result = paginateArray(sensors, page, pageSize);
-        return toToolResult({
-          page: result.page,
-          pageSize: result.pageSize,
-          totalCount: result.totalCount,
-          totalPages: result.totalPages,
-          entities: result.items,
-        });
-      }
-
-      // Default: return lightweight entities
-      const lightweight = sensors.map(toLightweight);
-      const result = paginateArray(lightweight, page, pageSize);
-      return toToolResult({
-        page: result.page,
-        pageSize: result.pageSize,
-        totalCount: result.totalCount,
-        totalPages: result.totalPages,
-        entities: result.items,
-      });
-    }, Permission.QUERY)
-  );
-}

package/src/tools/homeassistant/getAutomationTrace.ts

@@ -1,30 +0,0 @@
-/**
- * getAutomationTrace tool - Get automation execution history
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import { z } from 'zod';
-import type { HaClient } from '../../haClient/index.js';
-import { entityIdSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-export const getAutomationTraceSchema = entityIdSchema.extend({
-  limit: z.number().int().min(1).max(20).optional().describe('How many of the most recent runs to return (default 5, max 20)'),
-});
-
-type GetAutomationTraceArgs = z.infer<typeof getAutomationTraceSchema>;
-
-export function registerGetAutomationTraceTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getAutomationTrace',
-    {
-      description:
-        'Get the most recent runs of an automation, newest first: when it ran, what triggered it, how it ended (state, last step, error). ' +
-        'Only automations with an id (created in the UI, or YAML with an id) have traces.',
-      inputSchema: getAutomationTraceSchema,
-    },
-    wrapToolHandler('getAutomationTrace', async ({ entity_id, limit }: GetAutomationTraceArgs) => {
-      const traces = await client.getAutomationTrace(entity_id, limit);
-      return toToolResult({ entity_id, trace_count: traces.length, traces });
-    }, Permission.QUERY)
-  );
-}

package/src/tools/homeassistant/getDomainSummary.ts

@@ -1,29 +0,0 @@
-/**
- * getDomainSummary tool - Get summary of entities in a domain
- */
-
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { domainSchema, toToolResult, wrapToolHandler, Permission } from '../common.js';
-
-/**
- * Shared handler — used by the MCP registration below AND the chat face
- * (`POST /api/tools/getDomainSummary`) so both doors behave identically.
- */
-export function createGetDomainSummaryHandler(client: HaClient) {
-  return wrapToolHandler('getDomainSummary', async ({ domain }: { domain: string }) => {
-    const summary = await client.getDomainSummary(domain);
-    return toToolResult(summary);
-  }, Permission.QUERY);
-}
-
-export function registerGetDomainSummaryTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getDomainSummary',
-    {
-      description: 'Get a summary of entities in a domain, including counts and state breakdown.',
-      inputSchema: domainSchema,
-    },
-    createGetDomainSummaryHandler(client)
-  );
-}

package/src/tools/homeassistant/getEntitiesByDomain.ts

@@ -1,56 +0,0 @@
-/**
- * getEntitiesByDomain tool - Get all entities for a specific domain
- * Returns paginated, lightweight entities by default to reduce response size.
- */
-
-import { z } from 'zod';
-import type { McpServer } from '@modelcontextprotocol/server';
-import type { HaClient } from '../../haClient/index.js';
-import { toLightweight } from '../../types/index.js';
-import { toToolResult, wrapToolHandler, Permission, paginateArray } from '../common.js';
-
-const getEntitiesByDomainSchema = z.object({
-  domain: z.string().describe('Domain name (e.g., "light", "sensor", "switch", "climate")'),
-  page: z.number().int().min(1).default(1).describe('Page number (starts at 1)'),
-  pageSize: z.number().int().min(1).max(200).default(50).describe('Entities per page (1-200, default 50)'),
-  includeAttributes: z.boolean().default(false).describe('Include full attributes (increases response size significantly)'),
-});
-
-export function registerGetEntitiesByDomainTool(server: McpServer, client: HaClient): void {
-  server.registerTool(
-    'getEntitiesByDomain',
-    {
-      description: 'Get all entities for a specific domain (e.g., all lights, all sensors). Returns paginated lightweight entities by default (50 per page). Use includeAttributes=true for full entity data.',
-      inputSchema: getEntitiesByDomainSchema,
-    },
-    wrapToolHandler('getEntitiesByDomain', async (args) => {
-      const { domain, page, pageSize, includeAttributes } = args;
-      const allEntities = await client.getEntitiesByDomain(domain);
-
-      if (includeAttributes) {
-        // Return full entities with all attributes
-        const result = paginateArray(allEntities, page, pageSize);
-        return toToolResult({
-          domain,
-          page: result.page,
-          pageSize: result.pageSize,
-          totalCount: result.totalCount,
-          totalPages: result.totalPages,
-          entities: result.items,
-        });
-      }
-
-      // Default: return lightweight entities
-      const lightweight = allEntities.map(toLightweight);
-      const result = paginateArray(lightweight, page, pageSize);
-      return toToolResult({
-        domain,
-        page: result.page,
-        pageSize: result.pageSize,
-        totalCount: result.totalCount,
-        totalPages: result.totalPages,
-        entities: result.items,
-      });
-    }, Permission.QUERY)
-  );
-}