@thinremote/thinr-cli 1.2.0-alpha.1 → 1.3.0

package/lib/mcp/tools-alarms.js

@@ -0,0 +1,510 @@
+// @ts-check
+import {
+    getAlarmInstances,
+    getAlarmInstance,
+    getAlarmInstanceStats,
+    updateAlarmInstance,
+    deleteAlarmInstance,
+    getAlarmRules,
+    getAlarmRule,
+    createAlarmRule,
+    updateAlarmRule,
+    deleteAlarmRule,
+    parseAlarmState,
+    parseAlarmSeverity,
+    ALARM_STATE_LABEL,
+    ALARM_SEVERITY_LABEL,
+    ALARM_STATE,
+} from '../alarms.js';
+import { inputError } from '../errors.js';
+
+// Helpers ------------------------------------------------------------------
+
+function normalizeStateInput(value) {
+    if (value == null) return undefined;
+    const arr = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const v of arr) {
+        const parsed = parseAlarmState(v);
+        if (parsed === undefined) {
+            throw inputError(
+                `Unknown alarm state "${v}". Valid: active, ack, latched, shelved, cleared.`,
+            );
+        }
+        out.push(parsed);
+    }
+    return out;
+}
+
+function normalizeSeverityInput(value) {
+    if (value == null) return undefined;
+    const arr = Array.isArray(value) ? value : [value];
+    const out = [];
+    for (const v of arr) {
+        const parsed = parseAlarmSeverity(v);
+        if (parsed === undefined) {
+            throw inputError(
+                `Unknown alarm severity "${v}". Valid: low, medium, high, critical.`,
+            );
+        }
+        out.push(parsed);
+    }
+    return out;
+}
+
+function originLabel(inst) {
+    const origin = inst?.origin || {};
+    if (!origin.id && !origin.name) return '';
+    const id = origin.id || '';
+    const name = origin.name && origin.name !== id ? ` (${origin.name})` : '';
+    return ` ${id}${name}`;
+}
+
+function ageMsToHuman(ms) {
+    if (!Number.isFinite(ms) || ms <= 0) return '';
+    const sec = Math.floor(ms / 1000);
+    if (sec < 60) return `${sec}s`;
+    const min = Math.floor(sec / 60);
+    if (min < 60) return `${min}m`;
+    const h = Math.floor(min / 60);
+    if (h < 24) return `${h}h`;
+    const d = Math.floor(h / 24);
+    return `${d}d`;
+}
+
+function instanceAgeMs(inst) {
+    const v = inst?.created;
+    if (v == null) return 0;
+    if (typeof v === 'number') return Date.now() - v;
+    if (typeof v === 'object' && v.$date != null) {
+        const t = typeof v.$date === 'number' ? v.$date : Date.parse(v.$date);
+        return Number.isFinite(t) ? Date.now() - t : 0;
+    }
+    if (typeof v === 'string') {
+        const t = Date.parse(v);
+        return Number.isFinite(t) ? Date.now() - t : 0;
+    }
+    return 0;
+}
+
+function renderInstanceRow(inst) {
+    const id = inst?.instance || '?';
+    const rule = inst?.alarm?.rule || '?';
+    const sev = ALARM_SEVERITY_LABEL[inst?.severity ?? 0] || '?';
+    const state = ALARM_STATE_LABEL[inst?.state ?? 0] || '?';
+    const age = ageMsToHuman(instanceAgeMs(inst));
+    const ann = inst?.annotation ? `  note="${inst.annotation}"` : '';
+    return `[${state.padEnd(8)}] ${sev.padEnd(5)} ${id}  rule=${rule}${originLabel(inst)}${age ? `  age=${age}` : ''}${ann}`;
+}
+
+// Tools --------------------------------------------------------------------
+
+async function toolAlarmInstances(args) {
+    const state = normalizeStateInput(args.state);
+    const severity = normalizeSeverityInput(args.severity);
+    const list = await getAlarmInstances({
+        user: args.user,
+        count: Number.isFinite(args.count) && args.count > 0 ? Math.floor(args.count) : 100,
+        index: Number.isFinite(args.index) && args.index >= 0 ? Math.floor(args.index) : 0,
+        name: args.name,
+        state,
+        severity,
+        sort: args.sort,
+        order: args.order,
+    });
+
+    if (list.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No alarm instances match the filter.' }],
+            isError: false,
+        };
+    }
+
+    const lines = list.map(renderInstanceRow);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `${list.length} alarm instance(s):\n${lines.join('\n')}`,
+            },
+        ],
+        isError: false,
+    };
+}
+
+async function toolAlarmInstanceStats(args) {
+    const stats = await getAlarmInstanceStats({ user: args.user });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(stats, null, 2) }],
+        isError: false,
+    };
+}
+
+async function toolAlarmInstanceGet(args) {
+    if (!args.instance) throw inputError('instance is required');
+    const inst = await getAlarmInstance(args.instance, { user: args.user });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(inst, null, 2) }],
+        isError: false,
+    };
+}
+
+async function toolAlarmInstanceUpdate(args) {
+    if (!args.instance) throw inputError('instance is required');
+
+    const body = {};
+
+    if (args.state !== undefined) {
+        const parsed = parseAlarmState(args.state);
+        if (parsed === undefined) {
+            throw inputError(
+                `Unknown alarm state "${args.state}". Valid: active, ack, latched, shelved, cleared.`,
+            );
+        }
+        body.state = parsed;
+    }
+
+    if (args.annotation !== undefined) {
+        body.annotation = String(args.annotation);
+    }
+
+    if (args.reactivation_minutes !== undefined) {
+        const minutes = Number(args.reactivation_minutes);
+        if (!Number.isFinite(minutes) || minutes < 0) {
+            throw inputError('reactivation_minutes must be a non-negative number');
+        }
+        // The server expects the timespan with magnitude + value. Zero
+        // resets the scheduled reactivation, so we pass it through as-is.
+        body.reactivation = {
+            type: minutes > 0 ? 'timespan' : 'none',
+            timespan: { magnitude: 'minute', value: minutes },
+        };
+    } else if (args.reactivation !== undefined) {
+        body.reactivation = args.reactivation;
+    }
+
+    if (Object.keys(body).length === 0) {
+        throw inputError(
+            'Nothing to update. Pass at least one of: state, annotation, reactivation_minutes.',
+        );
+    }
+
+    const updated = await updateAlarmInstance(args.instance, body, { user: args.user });
+    const stateLabel = ALARM_STATE_LABEL[updated?.state ?? 0] || '?';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `Updated ${args.instance} → state=${stateLabel}` +
+                    (updated?.annotation ? `, annotation="${updated.annotation}"` : ''),
+            },
+        ],
+        isError: false,
+    };
+}
+
+async function toolAlarmInstanceDelete(args) {
+    if (!args.instance) throw inputError('instance is required');
+    await deleteAlarmInstance(args.instance, { user: args.user });
+    return {
+        content: [{ type: 'text', text: `Deleted alarm instance ${args.instance}.` }],
+        isError: false,
+    };
+}
+
+async function toolAlarmRules(args) {
+    const rules = await getAlarmRules({ user: args.user });
+    if (rules.length === 0) {
+        return {
+            content: [{ type: 'text', text: 'No alarm rules configured.' }],
+            isError: false,
+        };
+    }
+    const lines = rules.map((r) => {
+        const id = r.rule || r._id || '?';
+        const name = r.name && r.name !== id ? ` (${r.name})` : '';
+        const enabled = r.enabled ? '✓' : '✗';
+        const desc = r.description ? ` — ${r.description}` : '';
+        return `${enabled}  ${id}${name}${desc}`;
+    });
+    return {
+        content: [
+            { type: 'text', text: `${rules.length} alarm rule(s):\n${lines.join('\n')}` },
+        ],
+        isError: false,
+    };
+}
+
+async function toolAlarmRuleRead(args) {
+    if (!args.rule) throw inputError('rule is required');
+    const rule = await getAlarmRule(args.rule, { user: args.user });
+    return {
+        content: [{ type: 'text', text: JSON.stringify(rule, null, 2) }],
+        isError: false,
+    };
+}
+
+async function toolAlarmRuleWrite(args) {
+    if (!args.rule) throw inputError('rule is required');
+
+    // Decide create vs update by probing the server. The CREATE schema
+    // requires `rule`, `name`, `enabled`; UPDATE only accepts a subset.
+    let exists = false;
+    try {
+        await getAlarmRule(args.rule, { user: args.user });
+        exists = true;
+    } catch (e) {
+        if (e?.code !== 'not_found') throw e;
+    }
+
+    if (exists) {
+        const body = {};
+        if (args.name !== undefined) body.name = args.name;
+        if (args.description !== undefined) body.description = args.description;
+        if (args.enabled !== undefined) body.enabled = !!args.enabled;
+        if (args.config !== undefined) body.config = args.config;
+        if (Object.keys(body).length === 0) {
+            throw inputError(
+                'Nothing to update. Pass at least one of: name, description, enabled, config.',
+            );
+        }
+        await updateAlarmRule(args.rule, body, { user: args.user });
+        return {
+            content: [{ type: 'text', text: `Updated alarm rule "${args.rule}".` }],
+            isError: false,
+        };
+    }
+
+    if (!args.name) throw inputError('name is required when creating a rule');
+    if (args.enabled === undefined) {
+        throw inputError('enabled is required when creating a rule (true or false)');
+    }
+    const body = {
+        rule: args.rule,
+        name: args.name,
+        enabled: !!args.enabled,
+    };
+    if (args.description !== undefined) body.description = args.description;
+    if (args.config !== undefined) body.config = args.config;
+    await createAlarmRule(body, { user: args.user });
+    return {
+        content: [{ type: 'text', text: `Created alarm rule "${args.rule}".` }],
+        isError: false,
+    };
+}
+
+async function toolAlarmRuleDelete(args) {
+    if (!args.rule) throw inputError('rule is required');
+    await deleteAlarmRule(args.rule, { user: args.user });
+    return {
+        content: [{ type: 'text', text: `Deleted alarm rule "${args.rule}".` }],
+        isError: false,
+    };
+}
+
+// Description boilerplate shared by every tool that takes a state string.
+const STATE_DESC = `Alarm state, accepted as label or number: "active" (1), "ack" (2), "latched" (3), "shelved" (4), "cleared" (5). Numbers also accepted.`;
+const SEVERITY_DESC = `Alarm severity, accepted as label or number: "low" (1), "medium" (2), "high" (3), "critical" (4). Numbers also accepted.`;
+
+export const tools = [
+    {
+        name: 'thinr_alarm_instances',
+        description: `List active alarm instances across the fleet. Returns one row per instance with state, severity, instance id, originating rule, the device it fired on, and age. Filter by \`state\`, \`severity\` (single value or array), or \`name\` substring. By default the server returns up to 100 instances sorted state-asc, severity-desc, created-desc — use \`count\`/\`index\` to paginate. Use this first when triaging alerts; pair with thinr_alarm_instance_get for full evaluation/notification details and thinr_alarm_instance_update to acknowledge or shelve.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                state: {
+                    description: `Filter by ${STATE_DESC} Pass an array to combine ("active" + "ack").`,
+                    oneOf: [
+                        { type: 'string' },
+                        { type: 'number' },
+                        { type: 'array', items: { type: ['string', 'number'] } },
+                    ],
+                },
+                severity: {
+                    description: `Filter by ${SEVERITY_DESC} Pass an array to combine.`,
+                    oneOf: [
+                        { type: 'string' },
+                        { type: 'number' },
+                        { type: 'array', items: { type: ['string', 'number'] } },
+                    ],
+                },
+                name: {
+                    type: 'string',
+                    description: 'Server-side regex matched against the instance name.',
+                },
+                count: {
+                    type: 'number',
+                    description: 'Page size (default 100).',
+                },
+                index: {
+                    type: 'number',
+                    description: 'Page offset (default 0).',
+                },
+                sort: { type: 'string', description: 'Field to sort by.' },
+                order: { type: 'string', description: '"asc" or "desc".' },
+                user: { type: 'string', description: 'API user (admin impersonation).' },
+            },
+            required: [],
+        },
+        handler: toolAlarmInstances,
+    },
+    {
+        name: 'thinr_alarm_instance_stats',
+        description:
+            'Return counts of alarm instances grouped by state ({ activated, acknowledged, latched, shelved, cleared, none }). Use this to get a high-level health summary without pulling every instance.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: [],
+        },
+        handler: toolAlarmInstanceStats,
+    },
+    {
+        name: 'thinr_alarm_instance_get',
+        description:
+            'Fetch the full document for a single alarm instance, including evaluation values, notification history, annotation, and reactivation schedule. Use after thinr_alarm_instances to drill into a specific alert.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance: { type: 'string', description: 'Instance ID.' },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['instance'],
+        },
+        handler: toolAlarmInstanceGet,
+    },
+    {
+        name: 'thinr_alarm_instance_update',
+        description: `Modify an active alarm instance. Common operations:
+
+- Acknowledge: { state: "ack" } — the alert is muted but stays visible until cleared.
+- Shelve (silence temporarily): { state: "shelved", reactivation_minutes: 60 } — the rule is paused for that timespan.
+- Clear (mark resolved): { state: "cleared" }. Cleared alarms cannot be reactivated.
+- Annotate: { annotation: "investigated, false positive" } — adds a note visible in the UI.
+
+Pass any combination of fields. The backend rejects re-activating a cleared alarm. \`reactivation_minutes\` is a convenience that maps to the server's reactivation timespan; pass 0 to remove the schedule. For lower-level control pass \`reactivation\` as a raw object ({ type, timespan: { magnitude, value } }).`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance: { type: 'string', description: 'Instance ID.' },
+                state: {
+                    description: STATE_DESC,
+                    oneOf: [{ type: 'string' }, { type: 'number' }],
+                },
+                annotation: {
+                    type: 'string',
+                    description: 'Free-form note (max 512 chars). Visible in the dashboard.',
+                },
+                reactivation_minutes: {
+                    type: 'number',
+                    description:
+                        'Schedule the rule to reactivate after N minutes. 0 cancels any pending reactivation. Convenience wrapper over the raw `reactivation` object.',
+                },
+                reactivation: {
+                    type: 'object',
+                    description:
+                        'Raw reactivation object: { type: "none"|"timespan", timespan: { value, magnitude: "second"|"minute"|"hour"|"day"|"week"|"month"|"year" } }. Prefer reactivation_minutes for the common case.',
+                },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['instance'],
+        },
+        handler: toolAlarmInstanceUpdate,
+    },
+    {
+        name: 'thinr_alarm_instance_delete',
+        description:
+            'Permanently delete an alarm instance from history. Prefer thinr_alarm_instance_update with state="cleared" for normal lifecycle handling — deletion removes the audit trail.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                instance: { type: 'string', description: 'Instance ID.' },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['instance'],
+        },
+        handler: toolAlarmInstanceDelete,
+    },
+    {
+        name: 'thinr_alarm_rules',
+        description:
+            'List configured alarm rules with their enabled flag and description. Each row is one rule (the template that creates instances when its conditions fire). Use thinr_alarm_rule_read to see the full configuration of a single rule.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: [],
+        },
+        handler: toolAlarmRules,
+    },
+    {
+        name: 'thinr_alarm_rule_read',
+        description:
+            'Read the full configuration of a single alarm rule (activation conditions, data sources, severity, notifications, reminder, normalization). Returns the document as stored in the database — feed it back to thinr_alarm_rule_write to clone or edit.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rule: { type: 'string', description: 'Rule ID.' },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['rule'],
+        },
+        handler: toolAlarmRuleRead,
+    },
+    {
+        name: 'thinr_alarm_rule_write',
+        description: `Create or update an alarm rule. The tool first checks whether the rule exists: if missing it issues a CREATE (\`name\` and \`enabled\` are required); if present it issues an UPDATE with only the supplied fields. The \`config\` block carries the activation conditions, data sources, severity, normalization, reminder and notifications — its shape mirrors the backend's alarm_rule schema. To copy an existing rule, read it with thinr_alarm_rule_read, change \`rule\`, and pass the rest back here.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rule: {
+                    type: 'string',
+                    description: 'Stable rule ID. Cannot be changed after creation.',
+                },
+                name: { type: 'string', description: 'Display name (required on create).' },
+                description: { type: 'string', description: 'Free-form description.' },
+                enabled: {
+                    type: 'boolean',
+                    description:
+                        'Whether the rule is active. Required on create. On update, omit to keep the current value.',
+                },
+                config: {
+                    type: 'object',
+                    description:
+                        'Rule configuration: activation, normalization, data sources, severity, reminder, check_interval, notifications. Pass the full object as returned by thinr_alarm_rule_read.',
+                },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['rule'],
+        },
+        handler: toolAlarmRuleWrite,
+    },
+    {
+        name: 'thinr_alarm_rule_delete',
+        description:
+            'Delete an alarm rule. Active instances generated from the rule are stopped immediately, but historical instances stay in the database.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                rule: { type: 'string', description: 'Rule ID.' },
+                user: { type: 'string', description: 'API user.' },
+            },
+            required: ['rule'],
+        },
+        handler: toolAlarmRuleDelete,
+    },
+];
+
+// Re-export for tests / consumers that want to know which states are
+// considered "active" (everything except cleared).
+export const ALARM_NON_CLEARED_STATES = [
+    ALARM_STATE.NONE,
+    ALARM_STATE.ACTIVATED,
+    ALARM_STATE.ACKNOWLEDGED,
+    ALARM_STATE.LATCHED,
+    ALARM_STATE.SHELVED,
+];

package/lib/mcp/tools-buckets.js

@@ -0,0 +1,103 @@
+// @ts-check
+import { getBucketData } from '../bucket.js';
+import { inputError } from '../errors.js';
+
+async function toolBucketRead(args) {
+    if (!args.bucket)
+        throw inputError(
+            'bucket is required. Buckets are declared in the product profile (default: "monitoring").',
+        );
+    const data = await getBucketData({
+        bucket: args.bucket,
+        device: args.device,
+        user: args.user,
+        items: args.items || 10,
+        sort: args.sort || 'desc',
+        minutes: args.minutes,
+        min_ts: args.min_ts,
+        max_ts: args.max_ts,
+        agg: args.agg,
+        agg_type: args.agg_type,
+        fields: args.fields,
+        group_by: args.group_by,
+    });
+    const text =
+        Array.isArray(data) && data.length === 0
+            ? 'No data'
+            : JSON.stringify(data, null, 2);
+    return {
+        content: [{ type: 'text', text }],
+        isError: false,
+    };
+}
+
+export const tools = [
+    {
+        name: 'thinr_bucket_read',
+        description: `Query any time-series bucket declared in the product profile. Use this for custom metrics (domain data, business events, custom sensors) beyond the default \`monitoring\` bucket — for \`monitoring\` itself prefer \`thinr_monitoring\`, which formats the output.
+
+Modes:
+- device set: historical time series scoped to that device.
+- no device: user-level query across the fleet. By default returns raw interleaved samples; pass \`group_by=device\` (assuming the bucket tags samples with \`device\`) to get one row per device.
+
+Custom buckets may not share the \`monitoring\` schema — don't assume a \`device\` tag exists unless the product profile defines it.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                bucket: {
+                    type: 'string',
+                    description:
+                        'Bucket ID as declared in the product profile (e.g. "monitoring", or a custom one like "sensors", "events").',
+                },
+                device: {
+                    type: 'string',
+                    description:
+                        'Device ID. Omit for a one-row-per-device fleet view.',
+                },
+                items: {
+                    type: 'number',
+                    description:
+                        'Number of data points to return (default: 10). In multi-device mode set ≥ number of devices.',
+                },
+                minutes: {
+                    type: 'number',
+                    description:
+                        'Get data from the last N minutes. Alternative to min_ts/max_ts.',
+                },
+                min_ts: { type: 'number', description: 'Minimum timestamp in milliseconds' },
+                max_ts: {
+                    type: 'number',
+                    description: 'Maximum timestamp in milliseconds (0 = now)',
+                },
+                sort: {
+                    type: 'string',
+                    description:
+                        'Sort order by timestamp: "asc" or "desc" (default: "desc"). Does NOT sort by metric — do that client-side.',
+                },
+                agg: {
+                    type: 'string',
+                    description:
+                        'Time-window size for windowed aggregation: "5m", "10m", "1h", "6h". Only meaningful with a specific device. For a per-device single value across the whole range, omit `agg` and pass `agg_type` alone.',
+                },
+                agg_type: {
+                    type: 'string',
+                    description:
+                        'Reducer applied to each group/window. Supported: "mean", "max", "min", "sum", "count", "first", "last", "median", "spread", "stddev".',
+                },
+                fields: {
+                    type: 'string',
+                    description:
+                        'Comma-separated fields to return (e.g., "temperature,humidity"). Narrower queries are cheaper.',
+                },
+                group_by: {
+                    type: 'string',
+                    description:
+                        'Optional group key (e.g. "device" for a one-row-per-device fleet view). Omit for raw samples — custom buckets may not carry a "device" tag.',
+                },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['bucket'],
+        },
+        handler: toolBucketRead,
+    },
+];

package/lib/mcp/tools-devices.js

@@ -1,7 +1,8 @@
 // @ts-check
-import { getDevices, getDevice } from '../devices.js';
+import { getDevices, getDevice, deleteDevice } from '../devices.js';
 import { setDeviceProduct } from '../product.js';
 import { inputError } from '../errors.js';
+import { BYTES } from '../constants.js';
 import { getAPI } from './helpers.js';
 
 async function toolDevices(args) {
@@ -87,11 +88,11 @@ async function toolDeviceInfo(args) {
             );
         if (mon.memory)
             parts.push(
-                `Memory: ${mon.memory.usage?.toFixed(1)}% (${(mon.memory.total / 1073741824).toFixed(1)}GB total)`,
+                `Memory: ${mon.memory.usage?.toFixed(1)}% (${(mon.memory.total / BYTES.GB).toFixed(1)}GB total)`,
             );
         if (mon.disk?.root)
             parts.push(
-                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (${(mon.disk.root.total / 1073741824).toFixed(0)}GB total)`,
+                `Disk: ${mon.disk.root.usage?.toFixed(1)}% (${(mon.disk.root.total / BYTES.GB).toFixed(0)}GB total)`,
             );
         if (mon.network)
             parts.push(
@@ -131,6 +132,21 @@ async function toolDeviceSetProduct(args) {
     return { content: [{ type: 'text', text: label }], isError: false };
 }
 
+async function toolDeviceDelete(args) {
+    const device = args.device;
+    if (!device) throw inputError('device is required');
+    const removed = await deleteDevice(device, args.user);
+    return {
+        content: [
+            {
+                type: 'text',
+                text: removed ? `Deleted ${device}` : `Device ${device} did not exist`,
+            },
+        ],
+        isError: false,
+    };
+}
+
 export const tools = [
     {
         name: 'thinr_devices',
@@ -191,4 +207,18 @@ export const tools = [
         },
         handler: toolDeviceSetProduct,
     },
+    {
+        name: 'thinr_device_delete',
+        description:
+            'Delete a device record from the platform. Destructive and irreversible — drops the device, its server-side metadata, and stored properties. The agent on the host (if still running) will be left orphaned and will not auto-recreate the record. Idempotent: returns success when the device was already absent.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                device: { type: 'string', description: 'Device ID to delete.' },
+                user: { type: 'string', description: 'API user' },
+            },
+            required: ['device'],
+        },
+        handler: toolDeviceDelete,
+    },
 ];