rhombus-node-mcp 0.1.21 → 0.1.23

package/dist/tools/lpr-tool.js

@@ -1,4 +1,4 @@
-import { getSavedVehicles, getVehicleEvents, getVehicleLabels } from "../api/lpr-tool-api.js";
+import { getSavedVehicles, getVehicleEvents, getVehicleLabels, searchLicensePlates, saveVehicle } from "../api/lpr-tool-api.js";
 import { LprToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/lpr-tool-types.js";
 import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
 const TOOL_NAME = "lpr-tool";
@@ -14,7 +14,7 @@ is recognized by a rhombus security camera, it will attach the label to the even
 
 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} 
+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:
@@ -38,37 +38,43 @@ const TOOL_HANDLER = async (args, _extra) => {
                     }));
                 }
                 const vehicleEvents = await getVehicleEvents(vehicleEventsArgs, args.timeZone, requestModifiers, sessionId);
-                return createToolStructuredContent({
-                    vehicleEvents,
-                });
+                return createToolStructuredContent({ vehicleEvents });
             }
             case LprToolRequestType.GET_SAVED_VEHICLES: {
                 const savedVehicles = await getSavedVehicles(args.timeZone, requestModifiers, sessionId);
-                return createToolStructuredContent({
-                    savedVehicles,
-                });
+                return createToolStructuredContent({ savedVehicles });
             }
             case LprToolRequestType.GET_VEHICLE_LABELS: {
                 const vehicleLabels = await getVehicleLabels(requestModifiers, sessionId);
-                return createToolStructuredContent({
-                    vehicleLabels,
-                });
+                return createToolStructuredContent({ vehicleLabels });
+            }
+            case LprToolRequestType.SEARCH_LICENSE_PLATES: {
+                if (!args.licensePlateQuery) {
+                    return createToolStructuredContent({
+                        error: "licensePlateQuery is required for search-license-plates.",
+                    });
+                }
+                const results = await searchLicensePlates(args.licensePlateQuery, args.timeZone, requestModifiers, sessionId);
+                return createToolStructuredContent({ licensePlateSearchResults: results });
+            }
+            case LprToolRequestType.SAVE_VEHICLE: {
+                if (!args.vehicleName || !args.vehicleLicensePlate) {
+                    return createToolStructuredContent({
+                        error: "vehicleName and vehicleLicensePlate are required for save-vehicle.",
+                    });
+                }
+                const result = await saveVehicle(args.vehicleName, args.vehicleLicensePlate, args.vehicleDescription ?? undefined, requestModifiers, sessionId);
+                return createToolStructuredContent({ saveVehicleResult: result });
             }
         }
     }
     catch (error) {
         if (error instanceof Error) {
-            return createToolStructuredContent({
-                error: error.message,
-            });
+            return createToolStructuredContent({ error: error.message });
         }
-        return createToolStructuredContent({
-            error: "Unknown error",
-        });
+        return createToolStructuredContent({ error: "Unknown error" });
     }
-    return createToolStructuredContent({
-        error: "Invalid request type",
-    });
+    return createToolStructuredContent({ error: "Invalid request type" });
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {

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

@@ -1,5 +1,6 @@
-import { getExpiringPolicyAlerts, getPolicyAlerts } from "../api/policy-alerts-tool-api.js";
+import { dismissPolicyAlert, getExpiringPolicyAlerts, getPolicyAlertDetails, getPolicyAlertGroups, getPolicyAlerts, getUnhealthyDeviceAlerts, } from "../api/policy-alerts-tool-api.js";
 import { ApiPayloadSchema, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/policy-alerts-tool-types.js";
+import { extractFromToolExtra } from "../util.js";
 const TOOL_NAME = "policy-alerts-tool";
 const TOOL_DESCRIPTION = `
 Retrieves Rhombus policy alerts. Policy alerts in the Rhombus system are generated based on user-defined alert
@@ -20,16 +21,45 @@ policy alerts within the Rhombus system.
 This tool allows you to filter existing alerts by existing/expiring, a specific time range (before or after a timestamp in ISO 8601 format),
 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.`;
+The output is provided in JSON format.
+
+**Pagination**: Results are paginated and have a maximum page size. If the response includes a \`lastEvaluatedKey\` (for queryType "expiringSoon") or both \`lastTimestampISO\` and \`lastUuid\` (for queryTypes "existing" and "alert-groups"), more results are available. Pass these values back in the next call using the corresponding input parameters (lastEvaluatedKey, or lastTimestampISO and lastUuid) to retrieve the next page. Repeat until the response no longer includes these fields.
+
+IMPORTANT: The "unhealthy-devices" queryType returns historical alert notifications that were triggered for device health issues.
+It does NOT return live/real-time device connection status. If no device health alert policies are configured, or alerts were
+dismissed, this may return empty even when devices are offline.
+
+**To check which devices are currently online/offline, use the get-entity-tool instead.** The get-entity-tool returns the
+current state of all devices including their live connection status (the "connected" field). Request all entity types
+(CAMERA, DOORBELL_CAMERA, BADGE_READER, etc.) and check the "connected" field on each device to determine which are offline.`;
 const TOOL_HANDLER = async (args, extra) => {
     const payload = ApiPayloadSchema.parse(args);
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
     let ret;
     switch (args.queryType) {
         case "existing":
-            ret = await getPolicyAlerts(payload, extra._meta?.requestModifiers, extra.sessionId);
+            ret = await getPolicyAlerts(payload, requestModifiers, sessionId);
             break;
         case "expiringSoon":
-            await getExpiringPolicyAlerts(payload, extra._meta?.requestModifiers, extra.sessionId);
+            ret = await getExpiringPolicyAlerts(payload, requestModifiers, sessionId);
+            break;
+        case "details":
+            if (!args.alertUuid) {
+                throw new Error("alertUuid is required for 'details' queryType");
+            }
+            ret = await getPolicyAlertDetails(args.alertUuid, requestModifiers, sessionId);
+            break;
+        case "dismiss":
+            if (!args.alertUuid) {
+                throw new Error("alertUuid is required for 'dismiss' queryType");
+            }
+            ret = await dismissPolicyAlert(args.alertUuid, requestModifiers, sessionId);
+            break;
+        case "unhealthy-devices":
+            ret = await getUnhealthyDeviceAlerts(requestModifiers, sessionId);
+            break;
+        case "alert-groups":
+            ret = await getPolicyAlertGroups(payload, requestModifiers, sessionId);
             break;
         default:
             throw new Error(`Unsupported queryType: ${args.queryType}`);

package/dist/tools/report-tool.js

@@ -1,59 +1,103 @@
-import { TOOL_ARGS, OUTPUT_SCHEMA, RequestType, } from "../types/report-tool-types.js";
-import { getOccupancyCountReport, getSummaryCountReport, getOccupancyEnabledCameras, getLineCrossingEnabledCameras, getThresholdCrossingCountReport, findPromptConfigurations, getCustomLLMReport, } from "../api/report-tool-api.js";
+import { findPromptConfigurations, getAuditFeed, getCustomEventsReport, getCustomLLMReport, getDiagnosticFeed, getLineCrossingEnabledCameras, getOccupancyCountReport, getOccupancyEnabledCameras, getPeopleCountEvents, getSummaryCountReport, getThresholdCrossingCountReport, getThresholdCrossingEvents, getUniqueFaceCount, } from "../api/report-tool-api.js";
+import { logger } from "../logger.js";
+import { OUTPUT_SCHEMA, RequestType, TOOL_ARGS, } from "../types/report-tool-types.js";
+import { extractFromToolExtra } from "../util.js";
 const TOOL_NAME = "report-tool";
 const TOOL_DESCRIPTION = `
-This tool generates summary count reports for various types of data within the Rhombus system.
-It provides aggregated counts over specified time intervals and scopes.
-This tool should be used when users need high level summary reports, analytics, or aggregated counts of system events and activities.
-If types contains PEOPLE please understand that this is not a unique person count, it is a count of people detection events. 
-It's useful for getting a high level count of people, but not for getting a unique person count.
+**Scope:** This tool returns **aggregated counts and time-series summaries** over specified intervals and scopes. Use **events-tool** when you need raw, event-level data (individual events with timestamps). Use this tool for high-level reports, analytics, and trends—especially over periods of a day or more.
 
-This tool can also retrieve a list of cameras that have occupancy reporting enabled, which is useful as a first step
-before running GET_SUMMARY_COUNT_REPORT since the uuid pulled from summaryCountRequest should always be present on
-the list returned from getOccupancyEnabledCameras.
+---
 
-Additionally, this tool supports line crossing analytics:
-- GET_LINE_CROSSING_ENABLED_CAMERAS: Retrieves cameras at a location that have line crossing enabled, along with their configurations.
-  This should be called first to identify which cameras can be used for threshold crossing reports.
-- GET_THRESHOLD_CROSSING_COUNT_REPORT: Generates reports showing ingress and egress counts for line crossings over time.
-  Automatically calculates key metrics including:
-  • Average entries per hour
-  • Average exits per hour
-  • Hour with most entries (with timestamp and count)
-  • Hour with most exits (with timestamp and count)
-  • Busiest hour overall (total activity with breakdown)
-  Supports human and vehicle crossing detection with configurable time buckets (quarter hour, hour, day, week).
+**People / occupancy counting strategy**
 
-The tool also supports custom user-defined event reporting:
-- FIND_PROMPT_CONFIGURATIONS: Retrieves all custom event prompt configurations. This should be called first to discover
-  what custom events are available for reporting (e.g., "black dog sightings", "delivery truck arrivals", etc.).
-  Each configuration includes the prompt text, UUID, and promptType (COUNT, PERCENT, or BOOLEAN) needed for generating reports.
-- GET_CUSTOM_LLM_REPORT: Generates time series reports for a specific custom event using the prompt UUID.
-  The promptType field from the configuration determines which API endpoint is used:
-  • COUNT: Returns numeric counts (e.g., "3 black dogs detected")
-  • PERCENT: Returns percentage values (e.g., "75% occupancy")
-  • BOOLEAN: Returns true/false values (e.g., "parking lot full: true")
-  Returns aggregated data over specified time intervals (minutely, quarter-hourly, hourly, daily, weekly, monthly).
-  Use this after finding the appropriate prompt configuration to get historical data for custom events.
+When asked to count people on a camera or at a location, follow this strategy:
+1. **Always call GET_OCCUPANCY_ENABLED_CAMERAS first** to discover which cameras have occupancy counting enabled.
+2. If the target camera IS in the list, call **GET_OCCUPANCY_COUNT_REPORT** for that device. The response will automatically include a \`faceCountEnrichment\` field with the number of unique individuals identified by face recognition in the same time range. Present both data sources: occupancy estimate and unique face count.
+3. If the target camera is NOT in the list, **tell the user** that camera does not have occupancy counting enabled, and list the cameras that do. You can still call GET_SUMMARY_COUNT_REPORT with PEOPLE type — its response will also include \`faceCountEnrichment\` with unique face data as a fallback. If the PEOPLE count returns zero, the response will also include the list of occupancy-enabled cameras and a hint.
+4. When both occupancy data and face recognition data are available, **synthesize both** in your answer (e.g., "Occupancy estimates ~15 people. Face recognition identified 9 unique individuals during this period.").
+
+**PEOPLE type (in GET_SUMMARY_COUNT_REPORT):** Not a unique person count; it counts people-detection events. Requires people detection to be enabled on the camera. Use for high-level activity trends, not for deduplicated head counts.
+
+---
+
+**Summary and occupancy**
+- **GET_SUMMARY_COUNT_REPORT:** Aggregated counts (people, faces, motion, vehicles, etc.) over time at device, location, or org scope. Interval: minutely, hourly, daily, weekly, monthly, yearly. When called with PEOPLE type at DEVICE scope, the response is automatically enriched with face recognition data.
+- **GET_OCCUPANCY_ENABLED_CAMERAS:** List of cameras with occupancy reporting enabled. **Always call this first** before any people/occupancy counting request to verify camera support.
+- **GET_OCCUPANCY_COUNT_REPORT:** Occupancy count time series for a specific device over a time range. Response is automatically enriched with face recognition data. If the device does not support occupancy, the response will include a hint and the list of cameras that do.
+
+---
+
+**Line crossing**
+- **GET_LINE_CROSSING_ENABLED_CAMERAS:** Cameras at a location with line crossing enabled, plus their configs. Call first to see which cameras support threshold crossing reports.
+- **GET_THRESHOLD_CROSSING_COUNT_REPORT:** Ingress/egress counts for line crossings over time. Supports human and vehicle detection; bucket size: quarter hour, hour, day, week. Response includes computed metrics: average entries/exits per hour, hour with most entries/exits, busiest hour (with breakdown).
+
+---
+
+**Custom LLM events**
+- **FIND_PROMPT_CONFIGURATIONS:** All custom event prompt configurations (e.g. "black dog sightings", "delivery truck arrivals", "parking availability %"). Each has prompt text, UUID, and promptType (COUNT, PERCENT, BOOLEAN). Call first to discover available custom events.
+- **GET_CUSTOM_LLM_REPORT:** **This is the PRIMARY way to get custom event reports.** Aggregated time-series for one custom event by prompt UUID. Automatically selects the correct API based on promptType: COUNT (numeric counts), PERCENT (percentages), BOOLEAN (true/false). Intervals: minutely, quarter-hourly, hourly, daily, weekly, monthly. **Always use this for custom event reports, trends, and analytics.** Use FIND_PROMPT_CONFIGURATIONS first to get the promptUuid and promptType.
+- **GET_CUSTOM_EVENTS_REPORT:** Raw individual event values only (not aggregated). Use only when you need per-event granularity, not for reports or trends.
+
+---
+
+**Audit and diagnostics**
+- **GET_AUDIT_FEED:** Audit log of all user/admin actions in the org over a time range. Returns who did what and when (principalName, targetName, action, displayText).
+- **GET_DIAGNOSTIC_FEED:** Device diagnostic events over a time range.
+- **GET_THRESHOLD_CROSSING_EVENTS:** Individual line-crossing events (not aggregated counts).
+- **GET_PEOPLE_COUNT_EVENTS:** Most recent people count readings for specified devices.
 `;
 const TOOL_HANDLER = async (args, extra) => {
     const { requestType } = args;
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
     if (requestType === RequestType.GET_SUMMARY_COUNT_REPORT) {
         const { summaryCountRequest } = args;
         if (!summaryCountRequest) {
             throw new Error("summaryCountRequest is required");
         }
-        const { interval, scope, types, rangeStart, rangeEnd, uuid } = summaryCountRequest;
-        const report = await getSummaryCountReport(interval, scope, types, uuid ?? undefined, new Date(rangeEnd).getTime(), new Date(rangeStart).getTime(), extra._meta?.requestModifiers, extra.sessionId, args.summaryCountRequest.timeZone);
+        const { interval, scope, types, rangeStart, rangeEnd, uuid, timeZone } = summaryCountRequest;
+        const startTimeMs = new Date(rangeStart).getTime();
+        const endTimeMs = new Date(rangeEnd).getTime();
+        const report = await getSummaryCountReport(interval, scope, types, uuid ?? undefined, endTimeMs, startTimeMs, requestModifiers, sessionId, timeZone);
+        const enrichedReport = { ...report };
+        const isPeopleQuery = types.includes("PEOPLE") && scope === "DEVICE" && uuid;
+        if (isPeopleQuery) {
+            try {
+                const faceCount = await getUniqueFaceCount(uuid, startTimeMs, endTimeMs, requestModifiers, sessionId);
+                enrichedReport.faceCountEnrichment = faceCount;
+            }
+            catch (err) {
+                logger.error("Failed to fetch face count enrichment for summary report", err);
+            }
+            const allZero = !report?.timeSeriesDataPoints?.length ||
+                report.timeSeriesDataPoints.every((dp) => !dp.eventCountMap ||
+                    Object.values(dp.eventCountMap).every((v) => v === 0 || v === null || v === undefined));
+            if (allZero) {
+                try {
+                    const camerasReport = await getOccupancyEnabledCameras(requestModifiers, sessionId);
+                    enrichedReport.occupancyEnabledCameras = camerasReport?.cameras?.map((c) => ({
+                        uuid: c.uuid,
+                        name: c.name,
+                        locationUuid: c.locationUuid,
+                    }));
+                    enrichedReport.hint =
+                        "People detection returned zero results for this camera. This usually means people counting is not enabled on this device. " +
+                            "The occupancyEnabledCameras field lists cameras that support occupancy counting. " +
+                            "Face recognition data is available in faceCountEnrichment above.";
+                }
+                catch (err) {
+                    logger.error("Failed to fetch occupancy-enabled cameras for hint", err);
+                }
+            }
+        }
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(report),
+                    text: JSON.stringify(enrichedReport),
                 },
             ],
             structuredContent: {
-                summaryCountReport: report,
+                summaryCountReport: enrichedReport,
             },
         };
     }
@@ -63,21 +107,59 @@ const TOOL_HANDLER = async (args, extra) => {
             throw new Error("occupancyCountRequest is required");
         }
         const { deviceUuid, rangeStart, rangeEnd, interval } = occupancyCountRequest;
-        const report = await getOccupancyCountReport(deviceUuid, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), interval, extra._meta?.requestModifiers, extra.sessionId);
+        const startTimeMs = new Date(rangeStart).getTime();
+        const endTimeMs = new Date(rangeEnd).getTime();
+        const report = await getOccupancyCountReport(deviceUuid, startTimeMs, endTimeMs, interval, requestModifiers, sessionId);
+        const enrichedReport = { ...report };
+        try {
+            const faceCount = await getUniqueFaceCount(deviceUuid, startTimeMs, endTimeMs, requestModifiers, sessionId);
+            enrichedReport.faceCountEnrichment = faceCount;
+        }
+        catch (err) {
+            logger.error("Failed to fetch face count enrichment for occupancy report", err);
+        }
+        const allZero = !report?.timeSeriesDataPoints?.length ||
+            report.timeSeriesDataPoints.every((dp) => !dp.eventCountMap ||
+                Object.values(dp.eventCountMap).every((v) => v === 0 || v === null || v === undefined));
+        if (allZero) {
+            try {
+                const camerasReport = await getOccupancyEnabledCameras(requestModifiers, sessionId);
+                const enabledUuids = new Set(camerasReport?.cameras?.map((c) => c.uuid).filter(Boolean) ?? []);
+                if (!enabledUuids.has(deviceUuid)) {
+                    enrichedReport.occupancyEnabledCameras = camerasReport?.cameras?.map((c) => ({
+                        uuid: c.uuid,
+                        name: c.name,
+                        locationUuid: c.locationUuid,
+                    }));
+                    enrichedReport.hint =
+                        "This camera does not have occupancy counting enabled (no occupancy polygon defined). " +
+                            "The occupancyEnabledCameras field lists cameras that do support occupancy counting. " +
+                            "Face recognition data is available in faceCountEnrichment above.";
+                }
+                else {
+                    enrichedReport.hint =
+                        "This camera has occupancy counting enabled but returned zero counts for the requested time range. " +
+                            "Face recognition data is available in faceCountEnrichment above.";
+                }
+            }
+            catch (err) {
+                logger.error("Failed to fetch occupancy-enabled cameras for hint", err);
+            }
+        }
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify(report),
+                    text: JSON.stringify(enrichedReport),
                 },
             ],
             structuredContent: {
-                occupancyCountReport: report,
+                occupancyCountReport: enrichedReport,
             },
         };
     }
     if (requestType === RequestType.GET_OCCUPANCY_ENABLED_CAMERAS) {
-        const report = await getOccupancyEnabledCameras(extra._meta?.requestModifiers, extra.sessionId);
+        const report = await getOccupancyEnabledCameras(requestModifiers, sessionId);
         return {
             content: [
                 {
@@ -96,7 +178,7 @@ const TOOL_HANDLER = async (args, extra) => {
             throw new Error("lineCrossingEnabledCamerasRequest is required");
         }
         const { locationUuid } = lineCrossingEnabledCamerasRequest;
-        const report = await getLineCrossingEnabledCameras(locationUuid, extra._meta?.requestModifiers, extra.sessionId);
+        const report = await getLineCrossingEnabledCameras(locationUuid, requestModifiers, sessionId);
         return {
             content: [
                 {
@@ -114,8 +196,8 @@ const TOOL_HANDLER = async (args, extra) => {
         if (!thresholdCrossingCountRequest) {
             throw new Error("thresholdCrossingCountRequest is required");
         }
-        const { deviceUuid, rangeStart, rangeEnd, bucketSize, crossingObject, dedupe } = thresholdCrossingCountRequest;
-        const report = await getThresholdCrossingCountReport(deviceUuid, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), bucketSize, crossingObject, dedupe, extra._meta?.requestModifiers, extra.sessionId);
+        const { deviceUuid, rangeStart, rangeEnd, bucketSize, crossingObject, dedupe, } = thresholdCrossingCountRequest;
+        const report = await getThresholdCrossingCountReport(deviceUuid, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), bucketSize, crossingObject, dedupe, requestModifiers, sessionId);
         return {
             content: [
                 {
@@ -129,7 +211,7 @@ const TOOL_HANDLER = async (args, extra) => {
         };
     }
     if (requestType === RequestType.FIND_PROMPT_CONFIGURATIONS) {
-        const report = await findPromptConfigurations(extra._meta?.requestModifiers, extra.sessionId);
+        const report = await findPromptConfigurations(requestModifiers, sessionId);
         return {
             content: [
                 {
@@ -148,9 +230,9 @@ const TOOL_HANDLER = async (args, extra) => {
             throw new Error("customLLMReportRequest is required");
         }
         const { promptUuid, promptType, rangeStart, rangeEnd, interval } = customLLMReportRequest;
-        const report = await getCustomLLMReport(promptUuid, promptType, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), interval, extra._meta?.requestModifiers, extra.sessionId);
+        const report = await getCustomLLMReport(promptUuid, promptType, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), interval, requestModifiers, sessionId);
         // Log the report data to help debug
-        console.log("📊 Custom LLM Report Tool Response:", JSON.stringify({
+        logger.log("📊 Custom LLM Report Tool Response:", JSON.stringify({
             promptType,
             hasError: report?.error,
             dataPointsCount: report?.timeSeriesDataPoints?.length,
@@ -168,6 +250,61 @@ const TOOL_HANDLER = async (args, extra) => {
             },
         };
     }
+    if (requestType === RequestType.GET_AUDIT_FEED) {
+        const { auditFeedRequest } = args;
+        if (!auditFeedRequest) {
+            throw new Error("auditFeedRequest is required");
+        }
+        const report = await getAuditFeed(new Date(auditFeedRequest.startTime).getTime(), new Date(auditFeedRequest.endTime).getTime(), requestModifiers, sessionId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(report) }],
+            structuredContent: { auditFeedReport: report },
+        };
+    }
+    if (requestType === RequestType.GET_DIAGNOSTIC_FEED) {
+        const { diagnosticFeedRequest } = args;
+        if (!diagnosticFeedRequest) {
+            throw new Error("diagnosticFeedRequest is required");
+        }
+        const report = await getDiagnosticFeed(new Date(diagnosticFeedRequest.startTime).getTime(), new Date(diagnosticFeedRequest.endTime).getTime(), requestModifiers, sessionId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(report) }],
+            structuredContent: { diagnosticFeedReport: report },
+        };
+    }
+    if (requestType === RequestType.GET_THRESHOLD_CROSSING_EVENTS) {
+        const { thresholdCrossingEventsRequest } = args;
+        if (!thresholdCrossingEventsRequest) {
+            throw new Error("thresholdCrossingEventsRequest is required");
+        }
+        const report = await getThresholdCrossingEvents(thresholdCrossingEventsRequest.deviceUuid, new Date(thresholdCrossingEventsRequest.startTime).getTime(), new Date(thresholdCrossingEventsRequest.endTime).getTime(), requestModifiers, sessionId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(report) }],
+            structuredContent: { thresholdCrossingEventsReport: report },
+        };
+    }
+    if (requestType === RequestType.GET_CUSTOM_EVENTS_REPORT) {
+        const { customEventsReportRequest } = args;
+        if (!customEventsReportRequest) {
+            throw new Error("customEventsReportRequest is required");
+        }
+        const report = await getCustomEventsReport(customEventsReportRequest.promptUuid, new Date(customEventsReportRequest.startTime).getTime(), new Date(customEventsReportRequest.endTime).getTime(), customEventsReportRequest.interval, requestModifiers, sessionId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(report) }],
+            structuredContent: { customEventsReport: report },
+        };
+    }
+    if (requestType === RequestType.GET_PEOPLE_COUNT_EVENTS) {
+        const { peopleCountEventsRequest } = args;
+        if (!peopleCountEventsRequest) {
+            throw new Error("peopleCountEventsRequest is required");
+        }
+        const report = await getPeopleCountEvents(peopleCountEventsRequest.deviceUuids, requestModifiers, sessionId);
+        return {
+            content: [{ type: "text", text: JSON.stringify(report) }],
+            structuredContent: { peopleCountEventsReport: report },
+        };
+    }
     return {
         content: [
             {

package/dist/tools/rules-tool.js

@@ -0,0 +1,76 @@
+import { listRules, createRule, updateRule, deleteRule, getRuleRecords, } from "../api/rules-tool-api.js";
+import { RulesToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/rules-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "rules-tool";
+const TOOL_DESCRIPTION = `
+This tool manages Rhombus automation rules for triggering actions based on events.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${RulesToolRequestType.LIST}: List all automation rules in the organization.
+- ${RulesToolRequestType.CREATE}: Create a new automation rule. Requires ruleName and ruleConfig (JSON string with the rule definition).
+- ${RulesToolRequestType.UPDATE}: Update an existing rule. Requires ruleUuid and ruleConfig (JSON string with updated fields).
+- ${RulesToolRequestType.DELETE}: Delete a rule. Requires ruleUuid.
+- ${RulesToolRequestType.GET_RECORDS}: Get the event trigger history for a specific rule. Requires ruleUuid.
+
+Rules can trigger notifications, recordings, and other actions based on events from cameras, sensors, doors, etc.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case RulesToolRequestType.LIST: {
+                const rules = await listRules(requestModifiers, sessionId);
+                return createToolStructuredContent({ rules });
+            }
+            case RulesToolRequestType.CREATE: {
+                if (!args.ruleConfig) {
+                    return createToolTextContent(JSON.stringify({ error: "ruleConfig is required for create." }));
+                }
+                const config = JSON.parse(args.ruleConfig);
+                if (args.ruleName)
+                    config.name = args.ruleName;
+                const rule = await createRule(config, requestModifiers, sessionId);
+                return createToolStructuredContent({ rule });
+            }
+            case RulesToolRequestType.UPDATE: {
+                if (!args.ruleUuid || !args.ruleConfig) {
+                    return createToolTextContent(JSON.stringify({ error: "ruleUuid and ruleConfig are required for update." }));
+                }
+                const updateConfig = JSON.parse(args.ruleConfig);
+                updateConfig.ruleUuid = args.ruleUuid;
+                const rule = await updateRule(updateConfig, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    rule: { uuid: args.ruleUuid, ...rule },
+                });
+            }
+            case RulesToolRequestType.DELETE: {
+                if (!args.ruleUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "ruleUuid is required for delete." }));
+                }
+                const rule = await deleteRule(args.ruleUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ rule });
+            }
+            case RulesToolRequestType.GET_RECORDS: {
+                if (!args.ruleUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "ruleUuid is required for get-records." }));
+                }
+                const ruleRecords = await getRuleRecords(args.ruleUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ ruleRecords });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({ error: error.message });
+        }
+        return createToolStructuredContent({ error: "Unknown error" });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

package/dist/tools/search-tool.js

@@ -0,0 +1,69 @@
+import { searchLicensePlates, searchObjectsByColor, searchObjectsByText, searchMotionGrid, } from "../api/search-tool-api.js";
+import { SearchToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/search-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "search-tool";
+const TOOL_DESCRIPTION = `
+This tool performs visual and data searches across Rhombus camera footage and events.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${SearchToolRequestType.LICENSE_PLATE}: Search for license plate sightings by plate number. Requires query (the plate number or partial match).
+- ${SearchToolRequestType.OBJECT_BY_COLOR}: Search for objects by color in camera footage. Requires query (color name) and cameraUuid.
+- ${SearchToolRequestType.OBJECT_BY_TEXT}: Semantic search for objects in footage using a text description. Requires query (text description).
+- ${SearchToolRequestType.MOTION_SEARCH}: Search for motion events in a camera's field of view. Requires cameraUuid, startTime, and endTime.
+
+All search types support optional startTime and endTime to narrow the search window.
+Use the get-entity-tool with entityType CAMERA to get camera UUIDs.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        const startTimeMs = args.startTime ? new Date(args.startTime).getTime() : undefined;
+        const endTimeMs = args.endTime ? new Date(args.endTime).getTime() : undefined;
+        switch (args.requestType) {
+            case SearchToolRequestType.LICENSE_PLATE: {
+                if (!args.query) {
+                    return createToolTextContent(JSON.stringify({ error: "query is required for license-plate search." }));
+                }
+                const licensePlateResults = await searchLicensePlates(args.query, startTimeMs, endTimeMs, args.deviceUuids, args.locationUuids, requestModifiers, sessionId);
+                return createToolStructuredContent({ licensePlateResults });
+            }
+            case SearchToolRequestType.OBJECT_BY_COLOR: {
+                if (!args.query || !args.cameraUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "query and cameraUuid are required for object-by-color search." }));
+                }
+                const objectColorResults = await searchObjectsByColor(args.query, args.cameraUuid, startTimeMs, endTimeMs, requestModifiers, sessionId);
+                return createToolStructuredContent({ objectColorResults });
+            }
+            case SearchToolRequestType.OBJECT_BY_TEXT: {
+                if (!args.query) {
+                    return createToolTextContent(JSON.stringify({ error: "query is required for object-by-text search." }));
+                }
+                const textSearchDeviceUuids = args.deviceUuids
+                    ?? (args.cameraUuid ? [args.cameraUuid] : null);
+                const objectTextResults = await searchObjectsByText(args.query, startTimeMs, endTimeMs, textSearchDeviceUuids, requestModifiers, sessionId);
+                return createToolStructuredContent({ objectTextResults });
+            }
+            case SearchToolRequestType.MOTION_SEARCH: {
+                if (!args.cameraUuid || !startTimeMs || !endTimeMs) {
+                    return createToolTextContent(JSON.stringify({ error: "cameraUuid, startTime, and endTime are required for motion-search." }));
+                }
+                const motionResults = await searchMotionGrid(args.cameraUuid, startTimeMs, endTimeMs, requestModifiers, sessionId);
+                return createToolStructuredContent({ motionResults });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({ error: error.message });
+        }
+        return createToolStructuredContent({ error: "Unknown error" });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}