rhombus-node-mcp 0.1.28 → 0.1.30

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

@@ -4,9 +4,20 @@ import { postApi } from "../network/network.js";
 import { formatTimestamp } from "../util.js";
 import { tempFunc, TempUnit } from "../utils/temp.js";
 // Type definitions
-export const HumanEvent = z.object({
-    timestamp: z.number(),
-    id: z.number(),
+/** One entry from the camera VOD footage seekpoint index (many activity types). */
+export const CameraFootageEvent = z.object({
+    activity: z
+        .string()
+        .describe("Activity type on the recording timeline (e.g. MOTION_HUMAN, MOTION_CAR, LICENSEPLATE_IDENTIFIED—exact set depends on the camera and analytics)."),
+    timestamp: z.number().describe("Unix timestamp in milliseconds."),
+    id: z.number().optional().describe("Seekpoint id when the API provides one."),
+    licensePlate: z
+        .string()
+        .nullable()
+        .optional()
+        .describe("Plate text on this seekpoint when present. For org LPR saved vehicles, labels, and plate search APIs, use lpr-tool."),
+    vehicleName: z.string().nullable().optional().describe("Vehicle display name on this seekpoint when present."),
+    faceNames: z.string().nullable().optional().describe("Face names on this seekpoint when present."),
 });
 const ACCESS_CONTROL_EVENT_BATCH_SIZE = 1000;
 const ACCESS_CONTROL_EVENT_TYPE_FILTER = ["CredentialReceivedEvent"];
@@ -75,6 +86,71 @@ async function getAccessControlEventsForDoor(doorUuid, startTime, endTime, timeZ
     }
     return allEvents;
 }
+export async function getBrivoAccessControlEvents(startTime, endTime, timeZone, requestModifiers, sessionId) {
+    // Step 1: fetch Brivo integration config to get configured doors and their location UUIDs
+    const integrationResponse = await postApi({
+        route: "/integrations/accessControl/getBrivoIntegrationV2",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    const brivoSettings = integrationResponse.orgIntegrationV2;
+    const integrationEnabled = brivoSettings?.enabled ?? false;
+    const doorInfoMap = brivoSettings?.doorInfoMap ?? {};
+    const brivoDoors = Object.entries(doorInfoMap)
+        .filter(([, info]) => info != null)
+        .map(([brivoDoornId, info]) => ({
+        brivoDoornId,
+        doorName: info.doorName ?? undefined,
+        locationUuid: info.locationUuid ?? undefined,
+    }));
+    if (brivoDoors.length === 0) {
+        return {
+            integrationEnabled,
+            brivoDoorsConfigured: 0,
+            brivoDoors: [],
+            events: [],
+        };
+    }
+    // Step 2: collect unique location UUIDs from configured Brivo doors
+    const locationUuids = [...new Set(brivoDoors.map(d => d.locationUuid).filter((id) => !!id))];
+    // Step 3: query CredentialReceivedEvents for each location
+    const MAX_LIMIT = 1000;
+    const allEvents = [];
+    await Promise.all(locationUuids.map(async (locationUuid) => {
+        const body = {
+            locationUuid,
+            typeFilter: ["CredentialReceivedEvent"],
+            ...(startTime ? { createdAfterMs: startTime } : {}),
+            ...(endTime ? { createdBeforeMs: endTime } : {}),
+            limit: MAX_LIMIT,
+        };
+        const response = await postApi({
+            route: "/component/findComponentEventsByLocation",
+            body,
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        const mapped = (response.componentEvents || []).map(event => mapAccessControlEvent(event, timeZone));
+        allEvents.push(...mapped);
+    }));
+    allEvents.sort((a, b) => (b.timestampMs || 0) - (a.timestampMs || 0));
+    return {
+        integrationEnabled,
+        brivoDoorsConfigured: brivoDoors.length,
+        brivoDoors,
+        events: allEvents.map(e => ({
+            authenticationResult: e.authenticationResult ?? undefined,
+            authorizationResult: e.authorizationResult ?? undefined,
+            doorUuid: e.doorUuid ?? undefined,
+            locationUuid: e.locationUuid ?? undefined,
+            user: e.user ?? undefined,
+            credSource: e.credSource ?? undefined,
+            timestampMs: e.timestampMs ?? undefined,
+            datetime: e.datetime,
+        })),
+    };
+}
 export async function getFaceEvents(_locationUuid, timeZone, requestModifiers, sessionId) {
     const nowMs = Date.now();
     const rangeStartMs = nowMs - THREE_HOURS_MS;
@@ -121,7 +197,7 @@ export async function getAccessControlEvents(doorUuids, startTime, endTime, time
     console.error(`componentEvents: ${JSON.stringify(accessControlEvents)}`);
     return accessControlEvents;
 }
-export async function getHumanMotionEvents(cameraUuid, duration, startTime, requestModifiers, sessionId) {
+export async function getCameraFootageSeekpointEvents(cameraUuid, duration, startTime, requestModifiers, sessionId) {
     const body = {
         cameraUuid,
         duration,
@@ -132,25 +208,31 @@ export async function getHumanMotionEvents(cameraUuid, duration, startTime, requ
         body,
         modifiers: requestModifiers,
         sessionId,
-    }).then(response => {
-        const seekPoints = response.footageSeekPoints || [];
-        const uniqueHumanEvents = seekPoints
-            .reduceRight((acc, point) => {
-            if (point.a === "MOTION_HUMAN" &&
-                typeof point.ts === "number" &&
-                typeof point.id === "number" &&
-                !acc.some(existing => existing.id === point.id)) {
-                acc.unshift({ timestamp: point.ts, id: point.id });
-            }
-            return acc;
-        }, [])
-            .map(event => ({
-            timestamp: event.timestamp,
-            id: event.id,
-        }));
-        return { cameraUuid, uniqueHumanEvents };
     });
-    return response;
+    const seekPoints = response.footageSeekPoints ?? [];
+    const seen = new Set();
+    const cameraFootageEvents = [];
+    for (const point of seekPoints) {
+        if (typeof point.ts !== "number" || point.a == null) {
+            continue;
+        }
+        const idPart = point.id != null ? String(point.id) : "noid";
+        const dedupeKey = `${idPart}_${point.ts}_${point.a}`;
+        if (seen.has(dedupeKey)) {
+            continue;
+        }
+        seen.add(dedupeKey);
+        cameraFootageEvents.push({
+            activity: String(point.a),
+            timestamp: point.ts,
+            ...(point.id != null ? { id: point.id } : {}),
+            ...(point.lp !== undefined ? { licensePlate: point.lp } : {}),
+            ...(point.vn !== undefined ? { vehicleName: point.vn } : {}),
+            ...(point.fn !== undefined ? { faceNames: point.fn } : {}),
+        });
+    }
+    cameraFootageEvents.sort((a, b) => b.timestamp - a.timestamp);
+    return { cameraUuid, cameraFootageEvents };
 }
 const EVENT_COUNT_MAX_PER_RESPONSE = 2000;
 export async function getEventsForEnvironmentalGateway(deviceUuid, startTime, endTime, timeZone, tempUnit, requestModifiers, sessionId) {

package/dist/createServer.js

@@ -29,7 +29,7 @@ export default async function createServer() {
         version: "1.0.0",
     }, {
         capabilities: {
-            resources: {},
+            ...(resources.length > 0 ? { resources: {} } : {}),
             tools: {},
         },
     });

package/dist/tools/events-tool.js

@@ -1,4 +1,4 @@
-import { getAccessControlEvents, getEventsForEnvironmentalGateway, getClimateEventsForSensor, getComponentEventsByLocation, getHumanMotionEvents, getButtonPressEvents, getOccupancyEvents, getProximityEvents, getDoorbellEvents, } from "../api/events-tool-api.js";
+import { getAccessControlEvents, getBrivoAccessControlEvents, getEventsForEnvironmentalGateway, getClimateEventsForSensor, getComponentEventsByLocation, getCameraFootageSeekpointEvents, getButtonPressEvents, getOccupancyEvents, getProximityEvents, getDoorbellEvents, } from "../api/events-tool-api.js";
 import { EventsToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/events-tools-types.js";
 import { createToolStructuredContent } from "../util.js";
 import { getLogger } from "../logger.js";
@@ -9,7 +9,29 @@ const TOOL_NAME = "events-tool";
 const TOOL_DESCRIPTION = `
 **Scope:** This tool returns **raw, event-level data** (individual events with timestamps). Use **report-tool** when you need aggregated counts, time-series summaries, or analytics over intervals.
 
-This tool has 5 modes, set by "eventType": access-control, environmental-gateway, climate-sensor, component-events, camera. Use it when the user asks for specific events (unlocks, badge ins, credentials, arrivals, environmental readings, climate data, camera motion, or other component events). It can return large result sets; keep time ranges narrow. For ranges spanning more than ~24 hours, prefer report-tool for aggregates. For maximum flexibility across event types at a location, use eventType "component-events".
+**Vehicles vs lpr-tool:** **eventType "camera"** returns **footage seekpoints** from that camera's recording timeline—**every activity type** the API returns for the window (human motion, vehicle motion, and others depending on the camera and analytics). Some rows may include plate or vehicle metadata on the seekpoint. **lpr-tool** is still the right choice for **org LPR workflows**: saved vehicles, vehicle labels, fuzzy plate search, and vehicle event APIs—not a replacement for "everything this camera logged on its timeline."
+
+This tool has multiple modes, set by "eventType": access-control, brivo-access-control, environmental-gateway, climate-sensor, component-events, camera. Use it when the user asks for specific events (unlocks, badge ins, credentials, arrivals, environmental readings, climate data, camera timeline activity, or other component events). It can return large result sets; keep time ranges narrow. For ranges spanning more than ~24 hours, prefer report-tool for aggregates. For maximum flexibility across event types at a location, use eventType "component-events".
+
+---
+
+When eventType is "brivo-access-control":
+
+Retrieves badge/credential events from Brivo-integrated doors. Automatically fetches the Brivo integration configuration to determine which locations have Brivo doors mapped. No door UUIDs are required.
+
+Use this when the user asks specifically about Brivo events, Brivo badge ins, Brivo access control, or events from Brivo doors.
+
+Arguments:
+  * **startTime (string):** Start of the time range (ISO 8601).
+  * **endTime (string):** End of the time range (ISO 8601).
+
+Returns:
+  * **integrationEnabled:** Whether the Brivo integration is currently enabled.
+  * **brivoDoorsConfigured:** Number of Brivo doors configured in the integration.
+  * **brivoDoors:** List of Brivo doors with their IDs, names, and associated Rhombus location UUIDs.
+  * **events:** Credential received events from all locations that have Brivo doors configured, sorted newest first.
+
+Note: Events are fetched at the location level, so results may include events from all access-controlled doors at locations where Brivo is configured.
 
 ---
 
@@ -80,7 +102,7 @@ Valid event types include:
 
 When eventType is "camera":
 
-Retrieves human motion events for a camera in a time range. Timestamps in milliseconds.
+Retrieves **footage seekpoints** for one camera: **all activity types** returned for the search window (not limited to human motion). Each item includes an **activity** string plus **timestamp**; plate/vehicle/face fields appear when the API provides them. Use **lpr-tool** for org LPR saved vehicles, labels, and dedicated plate search.
 
 Arguments:
   * **cameraUuid (string):** UUID of the camera.
@@ -92,6 +114,13 @@ const TOOL_HANDLER = async (args, extra) => {
     const { eventType, accessControlledDoorUuids, deviceUuid, sensorUuid, locationUuid, componentEventTypes, startTime, endTime, limit, timeZone, tempUnit, cameraUuid, duration, buttonSensorUuid, occupancySensorUuid, proximityTagUuids, doorbellCameraUuid, } = args;
     logger.debug(`eventType: ${eventType}`);
     switch (eventType) {
+        case EventsToolRequestType.BRIVO_ACCESS_CONTROL: {
+            const result = await getBrivoAccessControlEvents(startTime ? new Date(startTime).getTime() : undefined, endTime ? new Date(endTime).getTime() : undefined, timeZone, extra._meta?.requestModifiers, extra.sessionId);
+            return createToolStructuredContent({
+                eventType: "brivo-access-control",
+                brivoAccessControlEvents: result,
+            });
+        }
         case "access-control": {
             if (!accessControlledDoorUuids || accessControlledDoorUuids.length === 0) {
                 return createToolStructuredContent({
@@ -148,8 +177,8 @@ const TOOL_HANDLER = async (args, extra) => {
                 });
             }
             else {
-                const events = await getHumanMotionEvents(cameraUuid, duration ?? 3600, startTime ? new Date(startTime).getTime() : Date.now() - 3600000, extra._meta?.requestModifiers, extra.sessionId);
-                return createToolStructuredContent({ eventType: "camera", cameraEvents: events.uniqueHumanEvents });
+                const events = await getCameraFootageSeekpointEvents(cameraUuid, duration ?? 3600, startTime ? new Date(startTime).getTime() : Date.now() - 3600000, extra._meta?.requestModifiers, extra.sessionId);
+                return createToolStructuredContent({ eventType: "camera", cameraEvents: events.cameraFootageEvents });
             }
         }
         case EventsToolRequestType.BUTTON_PRESS: {

package/dist/tools/lpr-tool.js

@@ -5,6 +5,8 @@ const TOOL_NAME = "lpr-tool";
 const TOOL_DESCRIPTION = `
 This tool interacts with the Rhombus LPR system to retrieve information about license plate recognition events and registered license plates.
 
+**Vs events-tool (camera):** **events-tool** with eventType **camera** returns that camera’s **VOD footage seekpoints** (many activity types on the timeline, including vehicle-related activity when present). **lpr-tool** is for the **LPR product surface**: plate events, **saved vehicles**, **labels**, and plate **search** APIs across the org—use it when the user needs registry, labeling, or org-wide LPR queries, not only “what showed up on this camera’s timeline.”
+
 The system's cameras may have LPR enabled, and when it is enabled, it will detect "license plate recognition" events when it sees a license plate
 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.

package/dist/types/access-control-tool-types.js

@@ -13,7 +13,7 @@ export var AccessControlRequestType;
     AccessControlRequestType["GET_REMOTE_UNLOCK_USERS"] = "get-remote-unlock-users";
 })(AccessControlRequestType || (AccessControlRequestType = {}));
 export const TOOL_ARGS = {
-    requestType: z.enum(AccessControlRequestType).describe("The type of access control request to make."),
+    requestType: z.nativeEnum(AccessControlRequestType).describe("The type of access control request to make."),
     doorUuid: z
         .string()
         .nullable()

package/dist/types/events-tools-types.js

@@ -1,11 +1,12 @@
 import { z } from "zod";
 import { ISOTimestampFormatDescription } from "../utils/timestampInput.js";
 import { ComponentEventEnumType } from "./schema.js";
-import { HumanEvent } from "../api/events-tool-api.js";
+import { CameraFootageEvent } from "../api/events-tool-api.js";
 import { TempUnit } from "../utils/temp.js";
 export var EventsToolRequestType;
 (function (EventsToolRequestType) {
     EventsToolRequestType["ACCESS_CONTROL"] = "access-control";
+    EventsToolRequestType["BRIVO_ACCESS_CONTROL"] = "brivo-access-control";
     EventsToolRequestType["ENVIRONMENTAL_GATEWAY"] = "environmental-gateway";
     EventsToolRequestType["CLIMATE_SENSOR"] = "climate-sensor";
     EventsToolRequestType["COMPONENT_EVENTS"] = "component-events";
@@ -20,10 +21,11 @@ export const TOOL_ARGS = {
         .nativeEnum(EventsToolRequestType)
         .describe("The type of events to retrieve. " +
         "access-control: Access control events like unlocks, badge ins, credentials, arrivals. " +
+        "brivo-access-control: Badge/credential events from Brivo-integrated doors. Does not require door UUIDs — automatically looks up which doors are configured via the Brivo integration. " +
         "environmental-gateway: Environmental gateway events with sensor readings and derived values. " +
         "climate-sensor: Climate sensor events with temperature, humidity, air quality readings. " +
         "component-events: All types of component events for a location (most flexible option). " +
-        "camera: Human motion events detected by cameras. " +
+        "camera: Footage seekpoints for one camera—all timeline activity types that camera recorded (human motion, vehicle motion, etc., depending on device/analytics). For org LPR saved vehicles, labels, and plate search APIs, use lpr-tool. " +
         "button-press: Button press events from button sensors. " +
         "occupancy: Occupancy sensor events with people count. " +
         "proximity: Proximity tag events with RSSI readings. " +
@@ -84,7 +86,7 @@ export const TOOL_ARGS = {
         .int()
         .positive()
         .nullable()
-        .describe("Duration in seconds to search for human motion events. Required when eventType is 'camera'. Default is 3600 (1 hour)."),
+        .describe("Duration in seconds to search footage seekpoints. Required when eventType is 'camera'. Default is 3600 (1 hour)."),
     buttonSensorUuid: z
         .string()
         .nullable()
@@ -143,6 +145,7 @@ export const OUTPUT_SCHEMA = z.object({
     eventType: z
         .enum([
         "access-control",
+        "brivo-access-control",
         "environmental-gateway",
         "climate-sensor",
         "component-events",
@@ -153,6 +156,52 @@ export const OUTPUT_SCHEMA = z.object({
         "doorbell",
     ])
         .optional(),
+    brivoAccessControlEvents: z.optional(z
+        .object({
+        integrationEnabled: z.boolean().describe("Whether the Brivo integration is enabled"),
+        brivoDoorsConfigured: z
+            .number()
+            .describe("Number of Brivo doors configured in the integration"),
+        brivoDoors: z
+            .array(z.object({
+            brivoDoornId: z.string().describe("Brivo's door ID"),
+            doorName: z.string().optional().describe("Brivo door name"),
+            locationUuid: z.string().optional().describe("Rhombus location UUID for this door"),
+        }))
+            .describe("List of Brivo doors configured in the integration"),
+        events: z
+            .array(z.object({
+            authenticationResult: z
+                .string()
+                .optional()
+                .describe("The result of the authentication process"),
+            authorizationResult: z
+                .string()
+                .optional()
+                .describe("The result of the authorization process"),
+            doorUuid: z
+                .string()
+                .optional()
+                .describe("The Rhombus access controlled door UUID"),
+            locationUuid: z
+                .string()
+                .optional()
+                .describe("The Rhombus location UUID where the event occurred"),
+            user: z.string().optional().describe("Username of the person who triggered the event"),
+            credSource: z
+                .string()
+                .optional()
+                .describe("The source of the credential (e.g. WIEGAND, NFC, BLE_WAVE, REMOTE)"),
+            timestampMs: z
+                .number()
+                .optional()
+                .describe("Timestamp in milliseconds when the event occurred"),
+            datetime: z.string().optional().describe("Formatted datetime string of the event"),
+        }))
+            .describe("Credential received events from locations that have Brivo doors configured, sorted by timestamp (newest first)"),
+    })
+        .nullable()
+        .describe("Brivo access control events. Fetches credential events from all locations that have Brivo doors configured in the integration.")),
     accessControlEvents: z.optional(z
         .array(z.object({
         authenticationResult: z
@@ -281,9 +330,9 @@ export const OUTPUT_SCHEMA = z.object({
         .nullable()
         .describe("Component events data for all types of access control events at a location, sorted by timestamp (newest first)")),
     cameraEvents: z
-        .array(HumanEvent)
+        .array(CameraFootageEvent)
         .optional()
-        .describe(`Camera events data, as requested with requestType ${EventsToolRequestType.CAMERA}`),
+        .describe(`Footage timeline seekpoints for the camera (all activity types returned in the window). Use with eventType "${EventsToolRequestType.CAMERA}".`),
     buttonPressEvents: z
         .array(z.object({
         timestampMs: z.number().optional(),

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

@@ -45,7 +45,9 @@ export const VehicleEventsArgs = z.object({
         ISOTimestampFormatDescription),
 });
 export const TOOL_ARGS = {
-    requestType: z.nativeEnum(LprToolRequestType).describe("The type of request to make."),
+    requestType: z
+        .nativeEnum(LprToolRequestType)
+        .describe("Org LPR operation (vehicle events, saved vehicles, labels, plate search, save vehicle). Per-camera VOD timeline seekpoints use events-tool (eventType camera)."),
     vehicleEventsArgs: VehicleEventsArgs.nullable().describe("Only necessary for requestType 'get-vehicle-events'"),
     timeZone: z
         .string()

package/package.json

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