rhombus-node-mcp 0.1.16 → 0.1.18

package/dist/api/camera-tool-api.js

@@ -2,6 +2,7 @@ import { getLogger } from "../logger.js";
 import { appendQueryParams, AUTH_HEADERS, postApi, STATIC_HEADERS } from "../network.js";
 import { removeNullFields } from "../util.js";
 const logger = getLogger("camera-tool");
+const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
 export async function getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers, sessionId) {
     const body = {
         cameraUuid: cameraUuid,
@@ -60,6 +61,54 @@ export async function getImageForCameraAtTime(cameraUuid, timestampMs, requestMo
         imageData: base64Image,
     };
 }
+async function getCameraStorageData(cameraUuid, requestModifiers, sessionId) {
+    // First, get the camera's full state to determine the time range and cloud archive days
+    const stateResponse = await postApi({
+        route: "/camera/getFullCameraState",
+        body: {
+            cameraUuid: cameraUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const cloudArchiveDays = stateResponse.fullCameraState?.onCloudState?.cloud_archive_days ?? null;
+    // Get the oldest segment time (in seconds) to use as start time
+    const oldestSegmentSecs = stateResponse.fullCameraState?.onCameraState?.oldest_segment_secs ?? 0;
+    const endTimeSec = Math.floor(Date.now() / 1000);
+    const startTimeSec = oldestSegmentSecs || 0;
+    const durationSec = endTimeSec - startTimeSec;
+    const presenceResponse = await postApi({
+        route: "/camera/getPresenceWindows",
+        body: {
+            cameraUuid: cameraUuid,
+            startTimeSec: startTimeSec,
+            durationSec: durationSec,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const calculateTotalDays = (timeWindows) => {
+        if (!timeWindows || timeWindows.length === 0) {
+            return 0;
+        }
+        let totalMilliseconds = 0;
+        timeWindows.forEach(window => {
+            if (window.startSeconds && window.durationSeconds) {
+                const durationMs = window.durationSeconds * 1000;
+                totalMilliseconds += durationMs;
+            }
+        });
+        return Math.floor(totalMilliseconds / MILLISECONDS_PER_DAY);
+    };
+    const presenceWindows = presenceResponse.presenceWindows;
+    const daysOnCamera = calculateTotalDays(presenceWindows?.VideoLocal);
+    const daysInCloud = calculateTotalDays(presenceWindows?.VideoCloud);
+    return {
+        daysInCloud,
+        daysOnCamera,
+        cloudArchiveDays,
+    };
+}
 export async function getCameraSettings(cameraUuid, requestModifiers, sessionId) {
     const res = await postApi({
         route: "/camera/getFacetedConfig",
@@ -75,9 +124,13 @@ export async function getCameraSettings(cameraUuid, requestModifiers, sessionId)
             status: "failed to fetch camera settings",
         };
     }
+    const storageData = await getCameraStorageData(cameraUuid, requestModifiers, sessionId);
     return {
         success: true,
         config: res.config,
+        daysInCloud: storageData.daysInCloud,
+        daysOnCamera: storageData.daysOnCamera,
+        cloudArchiveDays: storageData.cloudArchiveDays,
         status: "fetched camera settings",
     };
 }

package/dist/api/entity-lookup-tool-api.js

@@ -1,4 +1,20 @@
+import { postApi } from "../network.js";
 import { getAccessControlledDoors, getAudioGateways, getBadgeReaders, getButtons, getCameraList, getDoorbellCameras, getDoorSensors, getEnvironmentalGateways, getEnvironmentalSensors, getKeypads, getMotionSensors, } from "./get-entity-tool-api.js";
+async function getDeviceFeatures(deviceUuid, requestModifiers, sessionId) {
+    const response = await postApi({
+        route: "/feature/getDeviceFeatures",
+        body: { deviceUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (response.error || !response.features) {
+        return null;
+    }
+    return {
+        assignedLicense: response.features.assignedLicense,
+        featureMap: response.features.featureMap,
+    };
+}
 export async function getAllEntities(deviceUuids, timeZone, tempUnit, requestModifiers, sessionId) {
     const promises = [
         getCameraList(requestModifiers, sessionId),
@@ -14,7 +30,7 @@ export async function getAllEntities(deviceUuids, timeZone, tempUnit, requestMod
         getEnvironmentalGateways(timeZone, requestModifiers, sessionId),
     ];
     const responses = await Promise.all(promises);
-    // Filter each response to only include devices with matching UUIDs
+    // Filter each response to only include devices with matching UUIDs and fetch device features
     for (let i = 0; i < responses.length; i++) {
         const response = responses[i];
         // Look through keys and find any with an array
@@ -22,10 +38,22 @@ export async function getAllEntities(deviceUuids, timeZone, tempUnit, requestMod
             const value = response[key];
             if (Array.isArray(value)) {
                 // Filter to only include devices with matching UUIDs
-                response[key] = value.filter((item) => {
+                const filteredDevices = value.filter((item) => {
                     return deviceUuids.includes(item.uuid);
                 });
-                response[`${key}Count`] = response[key].length;
+                // Fetch device features for each filtered device
+                const devicesWithFeatures = await Promise.all(filteredDevices.map(async (device) => {
+                    const features = await getDeviceFeatures(device.uuid, requestModifiers, sessionId);
+                    return {
+                        ...device,
+                        ...(features && {
+                            assignedLicense: features.assignedLicense,
+                            featureMap: features.featureMap,
+                        }),
+                    };
+                }));
+                response[key] = devicesWithFeatures;
+                response[`${key}Count`] = devicesWithFeatures.length;
             }
         }
     }

package/dist/tools/camera-tool.js

@@ -22,7 +22,7 @@ or situational assessment. When invoked, the tool provides the following:
 
 What follows is a description of the behavior of this tool given the requestType "get-settings"
 
-This tool retrieves the current configuration for a specified camera or associated device (e.g., sensor, access controller). The returned JSON object can include detailed camera settings (e.g., resolution, bitrate) and various device-specific configurations.
+This tool retrieves the current configuration for a specified camera or associated device (e.g., sensor, access controller). The returned JSON object can include detailed camera settings (e.g., resolution, bitrate) and various device-specific configurations (e.g. storage settings).
 
 NOTE: To update camera settings, use the update-tool instead.
 `;

package/dist/tools/entity-lookup-tool.js

@@ -4,7 +4,8 @@ import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
 const TOOL_NAME = "entity-lookup-tool";
 const TOOL_DESCRIPTION = `
 Retrieves specific entities (or devices) by their UUIDs.
-Takes a list of device UUIDs and returns the device information for those specific devices.
+Takes a list of device UUIDs and returns the device information for those specific devices. 
+Use this tool when the user asks for details on devices' states and details about their licenses and features.
 The return structure is a JSON object that contains the states of the requested entities.
 This data is exact. Only devices with matching UUIDs will be returned.
 `;

package/dist/tools/location-tool.js

@@ -2,7 +2,7 @@ import { getLocations } from "../api/location-tool-api.js";
 import { TOOL_ARGS } from "../types/location-tool-types.js";
 const TOOL_NAME = "location-tool";
 const TOOL_DESCRIPTION = `This tool performs operations on locations.
-- 'get': Retrieves all locations.`;
+- 'get': Retrieves all locations.  When generating reports with location details, use location names not uuids.`;
 const TOOL_HANDLER = async (args, extra) => {
     const { action } = args;
     let ret;

package/dist/tools/lpr-tool.js

@@ -9,6 +9,14 @@ The system's cameras may have LPR enabled, and when it is enabled, it will detec
 come into view. However, it is possible that the recognized license is only a partial match, so keep that in mind when using this tool.
 Users will be able to save license plates into the system, and then additionally label them with a name.
 
+Regarding vehicle labels:  Users in the Rhombus LPR system can assign labels to vehicles.  When a vehicle (license plate) is assigned a label, and then later
+is recognized by a rhombus security camera, it will attach the label to the event and will be available on the events returned from (${LprToolRequestType.GET_SAVED_VEHICLES}).
+
+You should use the location-tool if trying to pair vehicle events to a particular location.  Never use location UUIDs in reports, use names.
+
+As such, if the user is asking anything about a label or labels it would be best practice to first call ${LprToolRequestType.GET_VEHICLE_LABELS} and then ${LprToolRequestType.GET_VEHICLE_EVENTS} 
+or ${LprToolRequestType.GET_VEHICLE_EVENTS}.
+
 This tool has 3 modes of operation, determined by the "requestType" parameter:
 - ${LprToolRequestType.GET_VEHICLE_EVENTS}: Retrieves a list of vehicle events that have been detected by the system. Please keep in mind that this has the *potential*
   to return a lot of data. However, 7 days should be a reasonable time range to start from if the user is not specific.

package/dist/tools/policy-alerts-tool.js

@@ -10,6 +10,8 @@ policies configured in the Rhombus Console. These policies trigger alerts when s
 * Physical or Visual Tamper: Detection of physical movement of a device or obstruction of a camera's field of view.
 * Access Control Events: Such as unauthorized access attempts in restricted areas.
 
+Alerts are generated on triggers, but are NOT the same as notifications. Only certain alerts generate notifications based on user settings.
+
 Can inquire about labels that have been seen.
 
 Please note, this is not an exhaustive list, and there may be other types of triggers or events that generate

package/dist/types/camera-tool-types.js

@@ -1,5 +1,44 @@
 import { z } from "zod";
 import { ISOTimestampFormatDescription } from "../utils/timestampInput.js";
+export const TimeWindowSecondsSchema = z.object({
+    startSeconds: z.number(),
+    durationSeconds: z.number(),
+});
+export const PresenceWindowsResponseSchema = z.object({
+    presenceWindows: z
+        .object({
+        VideoLocal: z.array(TimeWindowSecondsSchema).nullable().optional(),
+        VideoCloud: z.array(TimeWindowSecondsSchema).nullable().optional(),
+    })
+        .nullable(),
+});
+export const CameraDaysResultSchema = z.object({
+    daysInCloud: z.number(),
+    daysOnCamera: z.number(),
+});
+export const CameraFullStateResponseSchema = z.object({
+    fullCameraState: z
+        .object({
+        onCloudState: z
+            .object({
+            cloud_archive_days: z.number().optional(),
+        })
+            .nullable()
+            .optional(),
+        onCameraState: z
+            .object({
+            oldest_segment_secs: z.number().optional(),
+        })
+            .nullable()
+            .optional(),
+    })
+        .nullable(),
+});
+export const CameraStorageDataSchema = z.object({
+    daysInCloud: z.number(),
+    daysOnCamera: z.number(),
+    cloudArchiveDays: z.number().nullable(),
+});
 export const VideoFacetSettings = z
     .object({
     // blocked_debounce_time_ms: z.number().int().nullable(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",