rhombus-node-mcp 0.1.11 → 0.1.12

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

@@ -0,0 +1,172 @@
+import { z } from "zod";
+export const VideoFacetSettings = z
+    .object({
+    // blocked_debounce_time_ms: z.number().int().nullable(),
+    // blocked_threshold: z.number().int().nullable(),
+    // dewarpMode: z.enum([
+    //   'NO_TRANSFORM',
+    //   'NORMAL',
+    //   'PANORAMA',
+    //   'SUB_REGION',
+    //   'VERTICAL_PANORAMA',
+    //   'TRANSVERSE_MERCATOR',
+    //   'MERCATOR',
+    //   'EQUIRECTANGULAR',
+    // ]).nullable(),
+    // disabled_schedule: z.array(
+    //   z.object({
+    //     minuteOfWeekStart: z.number().int().nullable(),
+    //     minuteOfWeekStop: z.number().int().nullable(),
+    //   }).nullable()
+    // ).nullable(),
+    // disabled_schedule_inverted: z.boolean().nullable(),
+    // disabled_schedule_uuid: z.string().nullable(),
+    // exposure_level: z.number().nullable(),
+    // fisheye_display_mode: z.enum(['RAW', 'IMMERSIVE', 'TILES', 'RAW_PANO']).nullable(),
+    // floorplan_homography: z.array(z.array(z.number().nullable()).nullable()).nullable(),
+    hdr_enabled: z.boolean().nullable(),
+    img_brightness: z
+        .number()
+        .nullable()
+        .describe("Ranges from [-255, 255]. The image is described as a range from [0, 255], and the brightness slider will ADD this value to whatever the original value is. Use this accordingly."),
+    img_contrast: z
+        .number()
+        .nullable()
+        .describe("Ranges from [0, 128]. In general, 64 works for most situations, but adjust accordingly."),
+    img_saturation: z
+        .number()
+        .nullable()
+        .describe("Ranges from [0, 255]. In general, 64 works for most situations, but adjust accordingly."),
+    img_sharpness: z
+        .number()
+        .nullable()
+        .describe("Ranges from [0, 11]. In general, 6 works for most situations, but adjust accordingly."),
+    // metering_config: z.object({
+    //   rotation: z.number().nullable(),
+    //   table: z.string().nullable(),
+    // }).nullable(),
+    // motor_config: z.object({
+    //   af_enabled: z.boolean().nullable(),
+    //   af_region: z.object({
+    //     x: z.number().int().min(0).max(10000).nullable(),
+    //     y: z.number().int().min(0).max(10000).nullable(),
+    //     width: z.number().int().min(0).max(10000).nullable(),
+    //     height: z.number().int().min(0).max(10000).nullable(),
+    //   }).nullable(),
+    //   focus: z.number().nullable(),
+    //   piris: z.number().nullable(),
+    //   zoom: z.number().nullable(),
+    // }).nullable(),
+    // mounting_direction: z.enum(['DOWN', 'UP', 'SIDEWAYS', 'UNKNOWN']).nullable(),
+    night_exposure_level: z.number().nullable(),
+    night_img_brightness: z.number().nullable(),
+    night_img_contrast: z.number().nullable(),
+    night_img_saturation: z.number().nullable(),
+    night_img_sharpness: z.number().nullable(),
+    // night_metering_config: CameraMeteringConfigTypeSchema.nullable(),
+    night_sensor_gain_max: z.number().nullable(),
+    night_shutter_time_max: z.number().nullable(),
+    night_shutter_time_min: z.number().nullable(),
+    // object_search: z.boolean().nullable(),
+    // privacy_windows: z.array(
+    //   z.object({
+    //     x: z.number().int().min(0).max(10000).nullable(),
+    //     y: z.number().int().min(0).max(10000).nullable(),
+    //     width: z.number().int().min(0).max(10000).nullable(),
+    //     height: z.number().int().min(0).max(10000).nullable(),
+    //   }).nullable()
+    // ).nullable(),
+    // ptz_config: z.object({
+    //   offset_x_percent: z.number().nullable(),
+    //   offset_y_percent: z.number().nullable(),
+    //   rotation: z.number().nullable(),
+    //   size_percent: z.number().nullable(),
+    // }).nullable(),
+    // region_for_occupancy: z.object({
+    //   inverted: z.boolean().nullable(),
+    //   polygons: z.array(
+    //     z.object({
+    //       coordinates: z.array(
+    //         z.object({
+    //           x: z.number().nullable(),
+    //           y: z.number().nullable(),
+    //         }).nullable()
+    //       ).nullable(),
+    //     }).nullable()
+    //   ).nullable(),
+    // }).nullable(),
+    // region_of_interest: z.object({
+    //   inverted: z.boolean().nullable(),
+    //   polygons: z.array(
+    //     z.object({
+    //       coordinates: z.array(
+    //         z.object({
+    //           x: z.number().nullable(),
+    //           y: z.number().nullable(),
+    //         }).nullable()
+    //       ).nullable(),
+    //     }).nullable()
+    //   ).nullable(),
+    // }).nullable(),
+    // region_of_interest_groups: z.array(
+    //   z.object({
+    //     inclusive: z.boolean().nullable(),
+    //     regionsOfInterest: z.array(
+    //       z.object({
+    //         activities: z.array(z.string()).nullable(), // Assuming ActivityEnumSchema is just string
+    //         name: z.string().nullable(),
+    //         polygon: z.object({
+    //           coordinates: z.array(
+    //             z.object({
+    //               x: z.number().nullable(),
+    //               y: z.number().nullable(),
+    //             }).nullable()
+    //           ).nullable(),
+    //         }).nullable(),
+    //         uuid: z.string().nullable(),
+    //       }).nullable()
+    //     ).nullable(),
+    //     type: z.enum(['ACTIVITY', 'REPORTING', 'CROSSING']).nullable(),
+    //   }).nullable()
+    // ).nullable(),
+    resolution: z
+        .object({
+        width: z.number().int().positive().nullable(),
+        height: z.number().int().positive().nullable(),
+    })
+        .nullable(),
+    rotation: z.number().nullable(),
+    segment_max_bytes: z.number().nullable(),
+    sensor_gain_max: z.number().nullable(),
+    shutter_time_max: z.number().nullable(),
+    shutter_time_min: z.number().nullable(),
+    snapshot_height: z.number().nullable(),
+    snapshot_interval_secs: z.number().nullable(),
+    // tile_views: z.array(
+    //   z.object({
+    //     aspectRatio: z.object({
+    //       width: z.number().nullable(),
+    //       height: z.number().nullable(),
+    //     }).nullable(),
+    //     pitchDegrees: z.number().nullable(),
+    //     rollDegrees: z.number().nullable(),
+    //     verticalFieldOfViewDegrees: z.number().nullable(),
+    //     yawDegrees: z.number().nullable(),
+    //   }).nullable()
+    // ).nullable(),
+    // updatedSetMethodMap: z.record(z.boolean().nullable()).nullable(),
+    video_persist_disabled: z.boolean().nullable(),
+    // wdr_enabled: z.boolean().nullable(), TODO: find a way to tell the LLM which devices support this
+    wdr_strength: z.number().nullable().describe("Ranges from [0, 128]."),
+    zero_motion_video_bitrate_percent: z.number().nullable(),
+})
+    .nullable()
+    .describe("This describes the kind of settings that you can manipulate for a camera. If the user asks to change settings, only change what is necessary and don't pass in any fields that you do not need.");
+export const ExternalUpdateableFacetedUserConfigSchema = z.object({
+    /** Update Video Settings */
+    videoFacetSettings: z
+        .object({
+        v0: VideoFacetSettings,
+    })
+        .describe("For each of the object keys: v0, v1, v2, v3, they correspond to a specific facet of the camera, since a camera may have multiple facets, up to 4. Hence, why they are zero-indexed."),
+});

package/dist/tools/devices/get-entity-tool.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { postApi } from "../../network.js";
+import { createToolArgs, createToolTextContent } from "../../util.js";
+import DeviceType from "../../types/deviceType.js";
+async function getCameraList(requestModifiers) {
+    return {
+        cameras: (await postApi("/camera/getMinimalCameraStateList", "{}", requestModifiers)).cameraStates.filter((camera) => !!camera.locationUuid),
+    };
+}
+async function getDoorbellCameras(requestModifiers) {
+    return {
+        doorbellCameras: (await postApi("/doorbellcamera/getMinimalStateList", "{}", requestModifiers)).minimalStates.filter((doorbellCamera) => !!doorbellCamera.locationUuid),
+    };
+}
+async function getBadgeReaders(requestModifiers) {
+    return await postApi("/badgereader/getMinimalStateList", "{}", requestModifiers).then(response => {
+        return {
+            badgeReaders: response.minimalStates.filter((badgeReader) => !!badgeReader.locationUuid),
+        };
+    });
+}
+async function getAccessControlledDoors(requestModifiers) {
+    return await postApi("/component/findAccessControlledDoors", "{}", requestModifiers);
+}
+async function getAudioGateways(requestModifiers) {
+    return await postApi("/audiogateway/getMinimalAudioGatewayStateList", "{}", requestModifiers).then(response => {
+        return {
+            audioGateways: response.audioGatewayStates.filter((camera) => !!camera.locationUuid),
+        };
+    });
+}
+async function getDoorSensors(requestModifiers) {
+    return await postApi("/door/getMinimalDoorStateList", "{}", requestModifiers).then(response => {
+        return {
+            doorStates: response.doorStates.filter((door) => !!door.locationUuid),
+        };
+    });
+}
+async function getEnvironmentalSensors(requestModifiers) {
+    return await postApi("/climate/getMinimalClimateStateList", "{}", requestModifiers).then(response => {
+        return {
+            climateStates: response.climateStates.filter((sensor) => !!sensor.locationUuid),
+        };
+    });
+}
+async function getMotionSensors(requestModifiers) {
+    return await postApi("/occupancy/getMinimalOccupancySensorStateList", "{}", requestModifiers).then(response => {
+        return {
+            occupancySensorStates: response.occupancySensorStates.filter((occupancySensor) => !!occupancySensor.locationUuid),
+        };
+    });
+}
+async function getButtons(requestModifiers) {
+    return await postApi("/button/getMinimalButtonStateList", "{}", requestModifiers).then(response => {
+        return {
+            buttonStates: response.states.filter((button) => !!button.locationUuid),
+        };
+    });
+}
+async function getKeypads(requestModifiers) {
+    return await postApi("/keypad/getKeypadsForOrg", "{}", requestModifiers).then(response => {
+        return {
+            keypadStates: response.keypads.filter((keypad) => !!keypad.locationUuid),
+        };
+    });
+}
+export function createTool(server) {
+    server.tool("get-entity-tool", `
+    Retrieves entities (or devices) of certain types.
+    Can request multiple entity types at once.
+    The return structure is a JSON string that continues the states of the requested entities.
+    This data is exact. Whatever entities exist will be returned here.`, createToolArgs({
+        entityTypes: z
+            .array(z.nativeEnum(DeviceType).describe("The entity type to retreive"))
+            .describe("What type of entities to retrieve."),
+    }), async ({ entityTypes, requestModifiers }) => {
+        const promises = [];
+        if (entityTypes.includes(DeviceType.CAMERA)) {
+            promises.push(getCameraList(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.DOORBELL_CAMERA)) {
+            promises.push(getDoorbellCameras(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.BADGE_READER)) {
+            promises.push(getBadgeReaders(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.ACCESS_CONTROL_DOOR)) {
+            promises.push(getAccessControlledDoors(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.AUDIO_GATEWAY)) {
+            promises.push(getAudioGateways(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.DOOR_SENSOR)) {
+            promises.push(getDoorSensors(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.ENVIRONMENTAL_SENSOR)) {
+            promises.push(getEnvironmentalSensors(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.MOTION_SENSOR)) {
+            promises.push(getMotionSensors(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.BUTTON)) {
+            promises.push(getButtons(requestModifiers));
+        }
+        if (entityTypes.includes(DeviceType.KEYPAD)) {
+            promises.push(getKeypads(requestModifiers));
+        }
+        const responses = Promise.all(promises);
+        const ret = {
+            ...(await responses).reduce((prev, curr) => ({
+                ...prev,
+                ...curr
+            }), {})
+        };
+        return createToolTextContent(JSON.stringify(ret));
+    });
+}

package/dist/tools/events-tool.js

@@ -0,0 +1,101 @@
+import { z } from "zod";
+import { createToolArgs } from "../util.js";
+import { postApi } from "../network.js";
+import { THREE_HOURS_MS, FIVE_SECONDS_MS } from "../constants.js";
+async function getFaceEvents(_locationUuid, requestModifiers) {
+    const nowMs = Date.now();
+    const rangeStartMs = nowMs - THREE_HOURS_MS;
+    const rangeEndMs = nowMs - FIVE_SECONDS_MS;
+    const body = {
+        pageRequest: {
+            lastEvaluatedKey: undefined,
+            maxPageSize: 75,
+        },
+        searchFilter: {
+            deviceUuids: [],
+            faceNames: [],
+            labels: [],
+            locationUuids: [],
+            personUuids: [],
+            timestampFilter: {
+                rangeStart: rangeStartMs,
+                rangeEnd: rangeEndMs,
+            },
+        },
+    };
+    const response = await postApi("/faceRecognition/faceEvent/findFaceEventsByOrg", body, requestModifiers).then(response => {
+        return {
+            faceEvents: (response.faceEvents || []).map((event) => ({
+                ...event,
+                eventTimestamp: new Date(event.eventTimestamp).toString(),
+            })),
+        };
+    });
+    return response;
+}
+async function getAccessControlEvents(doorUuid, requestModifiers) {
+    const body = {
+        limit: 50,
+        accessControlledDoorUuid: doorUuid,
+    };
+    const response = await postApi("/component/findComponentEventsByAccessControlledDoor", body, requestModifiers).then(response => ({
+        componentEvents: (response.componentEvents || []).map((event) => ({
+            ...event,
+            timestamp: new Date(event.timestampMs).toString(),
+        })),
+    }));
+    return response;
+}
+export function createTool(server) {
+    server.tool("events-tool", "event data for certain types of information like faces, license plates, and access-control events", createToolArgs({
+        eventType: z.enum(["faces", "people", "access-control"]),
+        locationUuid: z.optional(z.string()),
+        accessControlledDoorUuid: z.optional(z.string()),
+    }), async ({ eventType, locationUuid, accessControlledDoorUuid, requestModifiers }) => {
+        if (eventType === "faces" || eventType === "people") {
+            const response = await getFaceEvents(locationUuid, requestModifiers);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(response),
+                    },
+                ],
+            };
+        }
+        if (eventType === "access-control") {
+            if (!accessControlledDoorUuid) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify({
+                                needUserInput: true,
+                                commandForUser: "Which door are you asking about?",
+                            }),
+                        },
+                    ],
+                };
+            }
+            else {
+                const events = await getAccessControlEvents(accessControlledDoorUuid, requestModifiers);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(events),
+                        },
+                    ],
+                };
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({}),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/faces-tool.js

@@ -0,0 +1,140 @@
+import { z } from "zod";
+import { postApi } from "../network.js";
+import { createToolArgs } from "../util.js";
+var RequestType;
+(function (RequestType) {
+    RequestType["GET_FACE_EVENTS"] = "get-face-events";
+    RequestType["GET_REGISTERED_FACES"] = "get-registered-faces";
+})(RequestType || (RequestType = {}));
+// Zod Schema for 'get-registered-faces' arguments (no specific args)
+const GetRegisteredFacesArgsSchema = z.object({
+    requestType: z.literal(RequestType.GET_REGISTERED_FACES),
+});
+// --- GetFaceEventsArgs Schema ---
+// All 'get-face-events' specific arguments are directly in this object,
+// marked as nullable since they are conditional based on requestType.
+const GetFaceEventsArgs = z.object({
+    // Arguments for 'get-face-events' (flattened from original searchFilter)
+    deviceUuids: z
+        .array(z.string())
+        .optional()
+        .describe("Optional filter by a set of device UUIDs. Only face events from these devices will be returned. Applicable when requestType is 'get-face-events'."),
+    faceNameContains: z
+        .string()
+        .optional()
+        .describe("Optional filter for face events where the detected face's name contains this substring. The search is performed only if the value is at least 3 characters long after trimming spaces. This takes precedence over 'faceNames' if both are specified. Applicable when requestType is 'get-face-events'."),
+    faceNames: z
+        .array(z.string())
+        .optional()
+        .describe("Optional filter by a set of specific person names. Only face events associated with these names will be returned. Applicable when requestType is 'get-face-events'."),
+    hasEmbedding: z
+        .boolean()
+        .optional()
+        .describe("Optional filter by the presence (true) or absence (false) of a face embedding associated with the event. Applicable when requestType is 'get-face-events'."),
+    hasName: z
+        .boolean()
+        .optional()
+        .describe("Optional filter by the presence (true) or absence (false) of a person name associated with the face event. Applicable when requestType is 'get-face-events'."),
+    labels: z
+        .array(z.string())
+        .optional()
+        .describe("Optional filter by a set of labels associated with the face event. Applicable when requestType is 'get-face-events'."),
+    locationUuids: z
+        .array(z.string())
+        .optional()
+        .describe("Optional filter by a set of location UUIDs. Only face events from these locations will be returned. Applicable when requestType is 'get-face-events'."),
+    personUuids: z
+        .array(z.string())
+        .optional()
+        .describe("Optional filter by a set of person UUIDs. Only face events associated with these specific people will be returned. Applicable when requestType is 'get-face-events'."),
+    // Arguments for 'get-face-events' (flattened from original timestampFilter)
+    rangeEnd: z
+        .string()
+        .optional()
+        .describe("The end of the time range (inclusive) for filtering face events. Expected format is a string containing a timestamp in milliseconds since epoch. Applicable when requestType is 'get-face-events'. If not specified, the filter defaults to the last 7 days."),
+    rangeStart: z
+        .string()
+        .optional()
+        .describe("The start of the time range (inclusive) for filtering face events. Expected format is a string containing a timestamp in milliseconds since epoch. Applicable when requestType is 'get-face-events'. If not specified, the filter defaults to the last 7 days."),
+    // No specific arguments for 'get-registered-faces' beyond requestType itself.
+});
+// --- Extracted PostAPI Calls into Functions ---
+async function getFaceEvents(args, requestModifiers) {
+    // Directly pass the args object as requested by the user
+    return await postApi("/faceRecognition/faceEvent/findFaceEventsByOrg", args, requestModifiers);
+}
+async function getRegisteredFaces(args, requestModifiers) {
+    // No specific arguments for this API call, so send an empty object.
+    return await postApi("/faceRecognition/person/findPeopleByOrg", {}, requestModifiers);
+}
+// --- Main Tool Definition ---
+export function createTool(server) {
+    server.tool("faces-tool", `
+This tool interacts with the Rhombus face recognition system to retrieve information about face events and registered faces. It has two primary modes of operation, determined by the "requestType" parameter:
+
+If the requestType is "get-face-events":
+
+  This tool retrieves detailed face events recorded by your Rhombus cameras, such as detections and recognitions. It provides comprehensive information about each event, including details about the detected face, the person matched (if any), and the event context.
+
+  You can filter face events using parameters like 'deviceUuids', 'faceNameContains', 'faceNames', 'hasEmbedding', 'hasName', 'labels', 'locationUuids', 'personUuids', and a time range using 'rangeStart' and 'rangeEnd' (timestamps in milliseconds).
+
+  The tool returns a JSON object with the following structure and important fields:
+  * **lastEvaluatedKey (string | null):** A key for pagination; if not null, it can be used to retrieve the next page of results.
+  * **faceEvents (array of objects | null):** An array where each object represents a single face event. Each face event object contains the following important fields:
+      * **uuid (string):** The unique identifier for this specific face event.
+      * **eventTimestamp (int64):** The timestamp (in milliseconds since epoch) when the face event occurred.
+      * **faceName (string | null):** The name of the person that matched the face image, if a match was found.
+      * **personUuid (string | null):** The UUID of the person that matched the face image, if a match was found.
+      * **deviceUuid (string):** The UUID of the device (e.g., camera) where the face event was detected.
+      * **locationUuid (string | null):** The UUID of the location where the face event occurred.
+      * **orgUuid (string | null):** The UUID of the organization associated with the event.
+      * **detectionConfidence (float | null):** A confidence value (between 0.0 and 1.0) indicating the likelihood that the detected image is a face.
+      * **thumbnailS3Key (string | null):** The S3 key for accessing the thumbnail image of the detected face.
+      * **selectedPersonMatch (object | null):** An object containing details about the top person match found for the face image, if any. Important fields within this object include:
+          * **confidence (float | null):** The match confidence level, expressed as a value in the range [0,1].
+          * **faceId (string | null):** The face ID of the matched person.
+          * **name (string | null):** The name of the matched person.
+          * **uuid (string | null):** The UUID of the matched person.
+
+If the requestType is "get-registered-faces":
+
+  This tool retrieves a list of all people (registered faces) currently known to the Rhombus system for your organization. This list includes information about each registered person.
+
+  This tool takes no arguments.
+
+  The tool returns a JSON object with the following structure and important fields:
+  * **people (array of objects | null):** An array where each object represents a registered person. Each person object contains the following important fields:
+      * **uuid (string):** The unique identifier for the registered person.
+      * **name (string | null):** The name associated with the registered person.
+      * **createdOn (date-time | null):** The date and time when the person was registered.
+      * **updatedOn (date-time | null):** The date and time when the person's information was last updated.
+      * **orgUuid (string | null):** The UUID of the organization to which the person belongs.
+
+`, 
+    // FacesToolArgs directly passed here
+    createToolArgs({
+        requestType: z.nativeEnum(RequestType),
+        args: z.union([
+            z.object({
+                args: GetFaceEventsArgs,
+            }),
+            z.object({
+                requestType: z.literal(RequestType.GET_REGISTERED_FACES),
+                args: GetRegisteredFacesArgsSchema,
+            }),
+        ]),
+    }), async ({ requestModifiers, requestType, args }) => {
+        let ret;
+        if (requestType === "get-face-events") {
+            // Pass the args directly, as requested
+            ret = await getFaceEvents(args, requestModifiers);
+        }
+        else if (requestType === "get-registered-faces") {
+            // Pass the args (will effectively be an empty object for this call)
+            ret = await getRegisteredFaces(args, requestModifiers);
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ret) }],
+        };
+    });
+}

package/dist/tools/get-org-information.js

@@ -0,0 +1,18 @@
+import { createToolArgs } from "../util.js";
+import { postApi } from "../network.js";
+async function getOrg(requestModifiers) {
+    return await postApi("/org/getOrgV2", {}, requestModifiers);
+}
+export function createTool(server) {
+    server.tool("get-org-information", "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.", createToolArgs({}), async ({ requestModifiers }) => {
+        const org = await getOrg(requestModifiers);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(org),
+                },
+            ],
+        };
+    });
+}

package/dist/tools/getTools.js

@@ -0,0 +1,22 @@
+import { fileURLToPath } from "node:url";
+import path from "path";
+import { getFilePathsInDirectory } from "../util.js";
+async function getTools() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const filePaths = getFilePathsInDirectory(currentDir);
+    const tools = [];
+    for (const filePath of filePaths) {
+        // ensure it's a js file
+        if (!filePath.endsWith(".js"))
+            continue;
+        const imported = (await import(filePath));
+        if (imported.createTool !== undefined) {
+            tools.push({
+                name: filePath,
+                create: imported.createTool,
+            });
+        }
+    }
+    return tools;
+}
+export default getTools;

package/dist/tools/location-tool.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { createToolArgs } from "../util.js";
+import { postApi } from "../network.js";
+async function getLocations(requestModifiers) {
+    return await postApi("/location/getLocationsV2", {}, requestModifiers);
+}
+export function createTool(server) {
+    server.tool("location-tool", `This tool performs operations on locations.
+- 'get': Retrieves all locations.`, createToolArgs({
+        action: z.enum(["get", "update"]),
+        locationUpdate: z
+            .object({
+            uuid: z.string(),
+            name: z.string(),
+        })
+            .optional(),
+    }), async ({ action, requestModifiers }) => {
+        let ret;
+        switch (action) {
+            case "get":
+                ret = await getLocations(requestModifiers);
+                break;
+            case "update":
+                ret = { error: true, status: "not implemented" };
+                break;
+            default:
+                ret = { error: true, status: `unsupported location tool call: ${action}` };
+                break;
+        }
+        return {
+            content: [{ type: "text", text: JSON.stringify(ret) }],
+        };
+    });
+}

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

@@ -0,0 +1,57 @@
+import { z } from "zod";
+import { postApi } from "../network.js";
+import { createToolArgs } from "../util.js";
+const PolicyAlertsArgs = z.object({
+    afterTimestampMs: z
+        .number()
+        .optional()
+        .describe("The start of the time range (in milliseconds since epoch) for which to retrieve alerts. Only alerts that occurred AFTER this timestamp will be returned."),
+    beforeTimestampMs: z
+        .number()
+        .optional()
+        .describe("The end of the time range (in milliseconds since epoch) for which to retrieve alerts. Only alerts that occurred BEFORE this timestamp will be returned."),
+    deviceFilter: z
+        .array(z.string())
+        .optional()
+        .describe("A list of UUIDs representing the specific devices to filter alerts by. Only alerts emitted by these devices will be returned."),
+    locationFilter: z
+        .array(z.string())
+        .optional()
+        .describe("A list of UUIDs representing the specific locations to filter alerts by. Only alerts associated with these locations will be returned."),
+    maxResults: z
+        .number()
+        .optional()
+        .describe("The maximum number of policy alerts to return. The system may default to a reasonable number (e.g., 20) if not specified, but there is a hard cap (e.g., 100) on the maximum results the API will return."),
+    // these may be pagination args, we'll leave them out for now
+    // lastTimestampMs: z.number().optional(),
+    // lastUuid: z.number().optional(),
+});
+async function getPolicyAlerts(args, requestModifiers) {
+    return await postApi("/event/getPolicyAlertsV2", args, requestModifiers);
+}
+export function createTool(server) {
+    server.tool("policy-alerts-tool", `
+Retrieves Rhombus policy alerts. Policy alerts in the Rhombus system are generated based on user-defined alert
+policies configured in the Rhombus Console. These policies trigger alerts when specific events occur, such as:
+* AI & Computer Vision Events: Based on intelligent video analytics for motion, people, vehicles, facial recognition,
+  license plate recognition, or unusual behavior.
+* Device Status Changes: Like camera disconnections or sensor low battery.
+* 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.
+
+Please note, this is not an exhaustive list, and there may be other types of triggers or events that generate
+policy alerts within the Rhombus system.
+
+This tool allows you to filter existing alerts by a specific time range (before or after a timestamp in milliseconds),
+by a list of device UUIDs, or by a list of location UUIDs.
+You can also specify the maximum number of results to return.
+The output is provided in JSON format.`, createToolArgs({
+        ...PolicyAlertsArgs.shape,
+    }), async ({ requestModifiers, ...args }) => {
+        let ret;
+        ret = await getPolicyAlerts(args, requestModifiers);
+        return {
+            content: [{ type: "text", text: JSON.stringify(ret) }],
+        };
+    });
+}