rhombus-node-mcp 0.1.21 → 0.1.23

package/dist/tools/analytics-tool.js

@@ -0,0 +1,383 @@
+import { getCountReportsForDevicesAtLocation, getRunningAverage, getLineCrossingEnabledCameras, getBatchThresholdCrossingCountReport, getSummaryCountReport, triggerScenePrompt, } from "../api/report-tool-api.js";
+import { AnalyticsRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/analytics-tool-types.js";
+import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
+import { postApi } from "../network.js";
+import { DateTime } from "luxon";
+const TOOL_NAME = "analytics-tool";
+const TOOL_DESCRIPTION = `
+This tool generates composite operational analytics reports by combining multiple data sources.
+Use it for high-level business questions about space utilization, traffic patterns, and real-time scene analysis.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${AnalyticsRequestType.SPACE_UTILIZATION}: Compare per-camera people counts against running averages at a location. Answers: "How busy is each area vs normal?"
+- ${AnalyticsRequestType.TRAFFIC_FLOW}: Compare ingress/egress across ALL line-crossing cameras at a location. Answers: "Which entrance gets the most traffic?"
+- ${AnalyticsRequestType.PEAK_VS_AVERAGE}: Show hourly actual counts vs historical averages. Answers: "When is it busiest? Is today above or below normal?"
+- ${AnalyticsRequestType.SCENE_INTELLIGENCE}: Ask a camera an arbitrary question using AI vision (e.g. "How many treadmills are in use?"). Works in real-time or at a historical timestamp.
+- ${AnalyticsRequestType.LOCATION_SUMMARY}: Generate a comprehensive multi-metric analytics summary for a location including people counts, traffic flow, and trend comparisons.
+`;
+async function handleSpaceUtilization(args, requestModifiers, sessionId) {
+    const req = args.spaceUtilizationRequest;
+    if (!req)
+        return { error: "spaceUtilizationRequest is required." };
+    const [deviceDataMap, averageData, camerasRes] = await Promise.all([
+        getCountReportsForDevicesAtLocation(req.locationUuid, req.startTimeMs, req.endTimeMs, req.interval, "PEOPLE", requestModifiers, sessionId),
+        getRunningAverage(req.locationUuid, req.startTimeMs, req.endTimeMs, req.interval, "LOCATION", undefined, requestModifiers, sessionId).catch(() => []),
+        getCameraNameMap(req.locationUuid, requestModifiers, sessionId),
+    ]);
+    const cameras = [];
+    let overallTotal = 0;
+    for (const [deviceUuid, dataPoints] of Object.entries(deviceDataMap)) {
+        let total = 0;
+        for (const dp of dataPoints) {
+            const counts = dp.eventCountMap ?? {};
+            for (const val of Object.values(counts)) {
+                if (typeof val === "number")
+                    total += val;
+            }
+        }
+        overallTotal += total;
+        cameras.push({
+            cameraUuid: deviceUuid,
+            cameraName: camerasRes[deviceUuid] ?? deviceUuid,
+            totalCount: total,
+        });
+    }
+    if (averageData.length > 0) {
+        let totalAvg = 0;
+        let avgCount = 0;
+        for (const dp of averageData) {
+            if (dp.stats) {
+                for (const stat of Object.values(dp.stats)) {
+                    if (stat?.avg != null) {
+                        totalAvg += stat.avg;
+                        avgCount++;
+                    }
+                }
+            }
+        }
+        const overallAvg = avgCount > 0 ? totalAvg / avgCount : 0;
+        for (const cam of cameras) {
+            const camAvg = overallAvg > 0 ? (overallAvg * cam.totalCount) / (overallTotal || 1) : undefined;
+            cam.averageCount = camAvg != null ? Math.round(camAvg * 100) / 100 : undefined;
+            if (cam.averageCount && cam.averageCount > 0) {
+                cam.deltaPercent = Math.round(((cam.totalCount - cam.averageCount) / cam.averageCount) * 10000) / 100;
+            }
+        }
+    }
+    cameras.sort((a, b) => b.totalCount - a.totalCount);
+    return {
+        spaceUtilization: {
+            locationUuid: req.locationUuid,
+            cameras,
+            summary: {
+                totalPeopleCount: overallTotal,
+                busiestCamera: cameras[0]?.cameraName,
+                quietestCamera: cameras[cameras.length - 1]?.cameraName,
+            },
+        },
+    };
+}
+async function handleTrafficFlow(args, requestModifiers, sessionId) {
+    const req = args.trafficFlowRequest;
+    if (!req)
+        return { error: "trafficFlowRequest is required." };
+    const lcCameras = await getLineCrossingEnabledCameras(req.locationUuid, requestModifiers, sessionId);
+    const configMap = lcCameras?.camerasToConfigs ?? {};
+    const deviceUuids = Object.keys(configMap);
+    if (deviceUuids.length === 0) {
+        return { error: "No line-crossing enabled cameras found at this location." };
+    }
+    const [batchData, cameraNames] = await Promise.all([
+        getBatchThresholdCrossingCountReport(deviceUuids, req.startTimeMs, req.endTimeMs, req.bucketSize, req.crossingObject, true, undefined, requestModifiers, sessionId),
+        getCameraNameMap(req.locationUuid, requestModifiers, sessionId),
+    ]);
+    const cameras = [];
+    let grandIngress = 0;
+    let grandEgress = 0;
+    for (const deviceUuid of deviceUuids) {
+        const counts = batchData[deviceUuid] ?? [];
+        let totalIngress = 0;
+        let totalEgress = 0;
+        let peakTraffic = 0;
+        let peakTimestamp;
+        for (const c of counts) {
+            const ing = c.ingressCount ?? 0;
+            const eg = c.egressCount ?? 0;
+            totalIngress += ing;
+            totalEgress += eg;
+            const total = ing + eg;
+            if (total > peakTraffic) {
+                peakTraffic = total;
+                peakTimestamp = c.timestampMs;
+            }
+        }
+        grandIngress += totalIngress;
+        grandEgress += totalEgress;
+        cameras.push({
+            cameraUuid: deviceUuid,
+            cameraName: cameraNames[deviceUuid] ?? deviceUuid,
+            totalIngress,
+            totalEgress,
+            totalTraffic: totalIngress + totalEgress,
+            peakHour: peakTimestamp
+                ? DateTime.fromMillis(peakTimestamp).toFormat("h:mm a, MMM d")
+                : undefined,
+            peakHourTraffic: peakTraffic > 0 ? peakTraffic : undefined,
+        });
+    }
+    cameras.sort((a, b) => b.totalTraffic - a.totalTraffic);
+    return {
+        trafficFlow: {
+            locationUuid: req.locationUuid,
+            cameras,
+            summary: {
+                totalIngress: grandIngress,
+                totalEgress: grandEgress,
+                totalTraffic: grandIngress + grandEgress,
+                busiestEntrance: cameras[0]?.cameraName,
+                busiestEntranceTraffic: cameras[0]?.totalTraffic,
+            },
+        },
+    };
+}
+async function handlePeakVsAverage(args, requestModifiers, sessionId) {
+    const req = args.peakVsAverageRequest;
+    if (!req)
+        return { error: "peakVsAverageRequest is required." };
+    const [actualReport, averageData] = await Promise.all([
+        getSummaryCountReport("HOURLY", req.scope, ["PEOPLE"], req.uuid ?? undefined, req.endTimeMs, req.startTimeMs, requestModifiers, sessionId, req.timeZone ?? undefined),
+        getRunningAverage(req.uuid ?? undefined, req.startTimeMs, req.endTimeMs, "HOURLY", req.scope, req.timeZone ?? undefined, requestModifiers, sessionId).catch(() => []),
+    ]);
+    const avgByHour = {};
+    for (const dp of averageData) {
+        if (dp.date && dp.stats) {
+            for (const stat of Object.values(dp.stats)) {
+                if (stat?.avg != null) {
+                    const hourKey = DateTime.fromISO(dp.date).toFormat("h a");
+                    avgByHour[hourKey] = (avgByHour[hourKey] ?? 0) + stat.avg;
+                }
+            }
+        }
+    }
+    const hourlyComparison = [];
+    const dataPoints = actualReport?.timeSeriesDataPoints ?? [];
+    for (const dp of dataPoints) {
+        const dateStr = dp.dateUtcString;
+        if (!dateStr)
+            continue;
+        let count = 0;
+        if (dp.eventCountMap) {
+            for (const val of Object.values(dp.eventCountMap)) {
+                if (typeof val === "number")
+                    count += val;
+            }
+        }
+        const hourLabel = DateTime.fromISO(dateStr).toFormat("h a");
+        const avg = avgByHour[hourLabel];
+        hourlyComparison.push({
+            hour: hourLabel,
+            actualCount: count,
+            averageCount: avg != null ? Math.round(avg * 100) / 100 : undefined,
+            deltaPercent: avg != null && avg > 0
+                ? Math.round(((count - avg) / avg) * 10000) / 100
+                : undefined,
+        });
+    }
+    let peakHour;
+    let peakCount = -1;
+    let quietHour;
+    let quietCount = Infinity;
+    for (const h of hourlyComparison) {
+        if (h.actualCount > peakCount) {
+            peakCount = h.actualCount;
+            peakHour = h.hour;
+        }
+        if (h.actualCount < quietCount) {
+            quietCount = h.actualCount;
+            quietHour = h.hour;
+        }
+    }
+    const totalActual = hourlyComparison.reduce((s, h) => s + h.actualCount, 0);
+    const totalAvg = hourlyComparison.reduce((s, h) => s + (h.averageCount ?? 0), 0);
+    const overallDelta = totalAvg > 0
+        ? Math.round(((totalActual - totalAvg) / totalAvg) * 10000) / 100
+        : undefined;
+    return {
+        peakVsAverage: {
+            hourlyComparison,
+            summary: {
+                peakHour,
+                peakHourCount: peakCount >= 0 ? peakCount : undefined,
+                quietestHour: quietHour,
+                quietestHourCount: quietCount < Infinity ? quietCount : undefined,
+                overallAverageDelta: overallDelta,
+            },
+        },
+    };
+}
+async function handleSceneIntelligence(args, requestModifiers, sessionId) {
+    const req = args.sceneIntelligenceRequest;
+    if (!req)
+        return { error: "sceneIntelligenceRequest is required." };
+    const result = await triggerScenePrompt(req.deviceFacetUuid, req.prompt, req.promptType, req.timestampMs ?? undefined, requestModifiers, sessionId);
+    return {
+        sceneIntelligence: {
+            value: result.value,
+            prompt: result.prompt,
+            timestampMs: result.timestampMs,
+            checkCondition: result.checkCondition,
+        },
+    };
+}
+async function handleLocationSummary(args, requestModifiers, sessionId) {
+    const req = args.locationSummaryRequest;
+    if (!req)
+        return { error: "locationSummaryRequest is required." };
+    const [deviceDataMap, averageData, lcCameras, cameraNames] = await Promise.all([
+        getCountReportsForDevicesAtLocation(req.locationUuid, req.startTimeMs, req.endTimeMs, "HOURLY", "PEOPLE", requestModifiers, sessionId).catch(() => ({})),
+        getRunningAverage(req.locationUuid, req.startTimeMs, req.endTimeMs, "HOURLY", "LOCATION", undefined, requestModifiers, sessionId).catch(() => []),
+        getLineCrossingEnabledCameras(req.locationUuid, requestModifiers, sessionId).catch(() => ({ camerasToConfigs: {} })),
+        getCameraNameMap(req.locationUuid, requestModifiers, sessionId),
+    ]);
+    let totalPeople = 0;
+    const hourlyTotals = {};
+    for (const [, dataPoints] of Object.entries(deviceDataMap)) {
+        for (const dp of dataPoints) {
+            const counts = dp.eventCountMap ?? {};
+            let dpTotal = 0;
+            for (const val of Object.values(counts)) {
+                if (typeof val === "number")
+                    dpTotal += val;
+            }
+            totalPeople += dpTotal;
+            const hour = dp.dateUtcString ? DateTime.fromISO(dp.dateUtcString).toFormat("h a") : "unknown";
+            hourlyTotals[hour] = (hourlyTotals[hour] ?? 0) + dpTotal;
+        }
+    }
+    let peakHour;
+    let peakCount = -1;
+    for (const [hour, count] of Object.entries(hourlyTotals)) {
+        if (count > peakCount) {
+            peakCount = count;
+            peakHour = hour;
+        }
+    }
+    const periodHours = Math.max(1, (req.endTimeMs - req.startTimeMs) / (1000 * 60 * 60));
+    const avgPerHour = Math.round((totalPeople / periodHours) * 100) / 100;
+    let trafficFlow = undefined;
+    const lcDeviceUuids = Object.keys(lcCameras.camerasToConfigs ?? {});
+    if (lcDeviceUuids.length > 0) {
+        try {
+            const batchData = await getBatchThresholdCrossingCountReport(lcDeviceUuids, req.startTimeMs, req.endTimeMs, "HOUR", "HUMAN", true, undefined, requestModifiers, sessionId);
+            let totalIngress = 0;
+            let totalEgress = 0;
+            let busiestEntrance;
+            let busiestTraffic = 0;
+            for (const deviceUuid of lcDeviceUuids) {
+                const counts = batchData[deviceUuid] ?? [];
+                let devIngress = 0;
+                let devEgress = 0;
+                for (const c of counts) {
+                    devIngress += c.ingressCount ?? 0;
+                    devEgress += c.egressCount ?? 0;
+                }
+                totalIngress += devIngress;
+                totalEgress += devEgress;
+                const devTotal = devIngress + devEgress;
+                if (devTotal > busiestTraffic) {
+                    busiestTraffic = devTotal;
+                    busiestEntrance = cameraNames[deviceUuid] ?? deviceUuid;
+                }
+            }
+            trafficFlow = { totalIngress, totalEgress, busiestEntrance };
+        }
+        catch {
+            // traffic flow data unavailable
+        }
+    }
+    let totalAvg = 0;
+    let avgPoints = 0;
+    for (const dp of averageData) {
+        if (dp.stats) {
+            for (const stat of Object.values(dp.stats)) {
+                if (stat?.avg != null) {
+                    totalAvg += stat.avg;
+                    avgPoints++;
+                }
+            }
+        }
+    }
+    const overallAvg = avgPoints > 0 ? totalAvg : 0;
+    const overallDelta = overallAvg > 0
+        ? Math.round(((totalPeople - overallAvg) / overallAvg) * 10000) / 100
+        : undefined;
+    return {
+        locationSummary: {
+            locationUuid: req.locationUuid,
+            peopleCounts: {
+                totalPeople,
+                averagePerHour: avgPerHour,
+                peakHour,
+                peakCount: peakCount >= 0 ? peakCount : undefined,
+            },
+            trafficFlow,
+            comparison: overallDelta != null
+                ? {
+                    overallDeltaPercent: overallDelta,
+                    trend: overallDelta > 0 ? "busier" : overallDelta < 0 ? "quieter" : "normal",
+                }
+                : undefined,
+        },
+    };
+}
+async function getCameraNameMap(locationUuid, requestModifiers, sessionId) {
+    try {
+        const res = await postApi({
+            route: "/camera/getMinimalCameraStateList",
+            body: {},
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        const map = {};
+        for (const cam of res.cameraStates ?? []) {
+            if (cam.locationUuid === locationUuid && cam.uuid && cam.name) {
+                map[cam.uuid] = cam.name;
+            }
+        }
+        return map;
+    }
+    catch {
+        return {};
+    }
+}
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case AnalyticsRequestType.SPACE_UTILIZATION:
+                return createToolStructuredContent(await handleSpaceUtilization(args, requestModifiers, sessionId));
+            case AnalyticsRequestType.TRAFFIC_FLOW:
+                return createToolStructuredContent(await handleTrafficFlow(args, requestModifiers, sessionId));
+            case AnalyticsRequestType.PEAK_VS_AVERAGE:
+                return createToolStructuredContent(await handlePeakVsAverage(args, requestModifiers, sessionId));
+            case AnalyticsRequestType.SCENE_INTELLIGENCE:
+                return createToolStructuredContent(await handleSceneIntelligence(args, requestModifiers, sessionId));
+            case AnalyticsRequestType.LOCATION_SUMMARY:
+                return createToolStructuredContent(await handleLocationSummary(args, requestModifiers, sessionId));
+        }
+    }
+    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/camera-tool.js

@@ -1,12 +1,15 @@
+import { getCameraSettings, getImageForCameraAtTime, getCameraMediaUris, getCameraAIThresholds } from "../api/camera-tool-api.js";
 import { getLogger } from "../logger.js";
-import { getCameraSettings, getImageForCameraAtTime } from "../api/camera-tool-api.js";
 import { BASE_TOOL_ARGS } from "../types/camera-tool-types.js";
+import { extractFromToolExtra } from "../util.js";
 const TOOL_NAME = "camera-tool";
 const TOOL_DESCRIPTION = `
-This tool can perform some action pertaining to the video stream of a camera. There are two types of requests
+This tool can perform some action pertaining to the video stream of a camera. There are four types of requests
 that can be passed into "requestType":
 - image
 - get-settings
+- get-media-uris
+- get-ai-thresholds
 
 What follows is a description of the behavior of this tool given the requestType "image"
 
@@ -18,7 +21,8 @@ This tool captures and returns a real-time snapshot from a designated security c
 The image reflects the current scene in the camera's field of view and serves as a contextual
 input source for downstream tasks such as object recognition, anomaly detection, incident investigation,
 or situational assessment. When invoked, the tool provides the following: 
-•  Visual Scene Capture: A high-resolution image of what the camera is actively observing, including people, vehicles, license plates, and any detectable objects.  
+- Visual Scene Capture: A high-resolution image of what the camera is actively observing, including people, vehicles, license plates, and any detectable objects.  
+- The frameUri that was used to fetch the image. It may be useful to show the user this image as well through the frameUri.
 
 What follows is a description of the behavior of this tool given the requestType "get-settings"
 
@@ -43,13 +47,13 @@ const TOOL_HANDLER = async (args, extra) => {
             ],
         };
     }
+    // biome-ignore lint/suspicious/noExplicitAny: this will be returned, and can be any type since it will be JSON.stringify'd
     let response;
-    const timestampMs = timestampISO
-        ? new Date(timestampISO).getTime()
-        : new Date().getTime() - 1000 * 60 * 5;
+    const timestampMs = timestampISO ? new Date(timestampISO).getTime() : Date.now() - 1000 * 60 * 5;
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
     switch (requestType) {
         case "image":
-            response = await getImageForCameraAtTime(cameraUuid, timestampMs, extra._meta?.requestModifiers, extra.sessionId);
+            response = await getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers, sessionId);
             if (!response.success || !response.imageData) {
                 return {
                     content: [{ type: "text", text: JSON.stringify(response) }],
@@ -70,12 +74,23 @@ const TOOL_HANDLER = async (args, extra) => {
                             status: "image-attached",
                             cameraUuid,
                             timestampMs,
+                            frameUri: response.frameUri,
                         }),
                     },
                 ],
             };
         case "get-settings":
-            response = await getCameraSettings(cameraUuid, extra._meta?.requestModifiers, extra.sessionId);
+            response = await getCameraSettings(cameraUuid, requestModifiers, sessionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        case "get-media-uris":
+            response = await getCameraMediaUris(cameraUuid, requestModifiers, sessionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        case "get-ai-thresholds":
+            response = await getCameraAIThresholds(cameraUuid, requestModifiers, sessionId);
             return {
                 content: [{ type: "text", text: JSON.stringify(response) }],
             };
@@ -96,5 +111,8 @@ const TOOL_HANDLER = async (args, extra) => {
     };
 };
 export function createTool(server) {
-    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+    }, TOOL_HANDLER);
 }

package/dist/tools/camera-uptime-tool.js

@@ -0,0 +1,50 @@
+import { getCameraUptime, getFleetUptime } from "../api/camera-uptime-tool-api.js";
+import { CameraUptimeRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/camera-uptime-tool-types.js";
+import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
+const TOOL_NAME = "camera-uptime-tool";
+const TOOL_DESCRIPTION = `
+This tool analyzes camera uptime and reliability over a time period. It computes uptime percentages, outage counts, and longest outage durations.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${CameraUptimeRequestType.GET_CAMERA_UPTIME}: Get uptime statistics for a single camera. Requires cameraUuid, startTimeSec, and endTimeSec.
+- ${CameraUptimeRequestType.GET_FLEET_UPTIME}: Get uptime statistics for ALL cameras in the organization, sorted by worst uptime first. Includes a fleet-wide summary with averages. Requires startTimeSec and endTimeSec.
+
+startTimeSec and endTimeSec are UNIX timestamps in seconds.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case CameraUptimeRequestType.GET_CAMERA_UPTIME: {
+                if (!args.cameraUuid) {
+                    return createToolStructuredContent({
+                        error: "cameraUuid is required for get-camera-uptime.",
+                    });
+                }
+                const cameraUptime = await getCameraUptime(args.cameraUuid, args.startTimeSec, args.endTimeSec, requestModifiers, sessionId);
+                return createToolStructuredContent({ cameraUptime });
+            }
+            case CameraUptimeRequestType.GET_FLEET_UPTIME: {
+                const result = await getFleetUptime(args.startTimeSec, args.endTimeSec, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    fleetUptime: result.cameras,
+                    fleetSummary: result.summary,
+                });
+            }
+        }
+    }
+    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/clips-tool.js

@@ -1,17 +1,22 @@
-import { ApiPayloadSchema, TOOL_ARGS } from "../types/clips-tool-types.js";
-import { getSavedClips, getExpiringClips } from "../api/clips-tool-api.js";
+import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
+import { ApiPayloadSchema, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/clips-tool-types.js";
+import { getSavedClips, getExpiringClips, getSharedLiveStreams, getTimelapseClips, getClipGroups, getSharedClipGroups, createClip, deleteClip, } from "../api/clips-tool-api.js";
 const TOOL_NAME = "clips-tool";
 const TOOL_DESCRIPTION = `
 Retrieves saved video clips from the Rhombus system. Saved clips can be viewed for up to 2 years and are typically found in the "Clips" tab of the "Saved Video" section of the Rhombus Console.
 Clips are either manually saved by the user, or automatically by some defined policy. Therefore, this tool
 is not for looking up the events that have occured.
 
-This tool allows you to filter clips by:
-* Whether or not they are expiring soon.
-* Specific devices using their UUIDs.
-* Specific locations using their UUIDs.
-* A simple string search on clip names.
-* A time range, specifying a start (timestampISOAfter) and/or end (timestampISOBefore) timestamp in ISO 8601 format.
+This tool allows you to:
+* Get saved clips or clips expiring soon (filter by devices, locations, search string, time range).
+* Get all shared live video streams for the organization.
+* Get all timelapse clips for the organization.
+
+Filter options (for saved and expiringSoon only):
+* Specific devices using their UUIDs (deviceUuidFilters).
+* Specific locations using their UUIDs (locationUuidFilters).
+* A simple string search on clip names (searchFilter).
+* A time range: start (timestampISOAfter) and/or end (timestampISOBefore) timestamp in ISO 8601 format.
 
 The tool returns a JSON object with the following structure and important fields:
 * **errorMsg (string | null):** An error message if the request failed.
@@ -30,20 +35,45 @@ The tool returns a JSON object with the following structure and important fields
     * **status (string):** The current processing status of the clip, with possible values such as INITIATING, UPLOADING, RENDERING, FAILED, COMPLETE, OFFLINE, or UNKNOWN.
     * **userUuid (string | null):** The UUID of the user associated with the clip, if applicable.
     * **sourceAlertUuid (string | null):** The UUID of the alert that triggered the creation of this clip, if any.
+* **sharedLiveVideoStreams (array):** When requestType is sharedLiveStreams, list of shared live video stream objects.
+* **timelapseClips (array):** When requestType is timelapseClips, list of timelapse clip objects.
+
 `;
 const TOOL_HANDLER = async (args, extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
     const payload = ApiPayloadSchema.parse(args);
-    let ret;
-    switch (args.queryType) {
+    switch (args.requestType) {
         case "saved":
-            ret = await getSavedClips(payload, extra._meta?.requestModifiers, extra.sessionId);
+            return createToolStructuredContent(await getSavedClips(payload, requestModifiers, sessionId));
         case "expiringSoon":
-            ret = await getExpiringClips(payload, extra._meta?.requestModifiers, extra.sessionId);
+            return createToolStructuredContent(await getExpiringClips(payload, requestModifiers, sessionId));
+        case "sharedLiveStreams":
+            return createToolStructuredContent(await getSharedLiveStreams(payload, requestModifiers, sessionId));
+        case "timelapseClips":
+            return createToolStructuredContent(await getTimelapseClips(payload, requestModifiers, sessionId));
+        case "clipGroups":
+            return createToolStructuredContent(await getClipGroups(requestModifiers, sessionId));
+        case "sharedClips":
+            return createToolStructuredContent(await getSharedClipGroups(requestModifiers, sessionId));
+        case "createClip": {
+            if (!args.spliceRequest) {
+                throw new Error("spliceRequest is required for 'createClip' requestType");
+            }
+            return createToolStructuredContent(await createClip(args.spliceRequest.cameraUuid, args.spliceRequest.startTimeMs, args.spliceRequest.endTimeMs, requestModifiers, sessionId));
+        }
+        case "deleteClip": {
+            if (!args.clipUuid) {
+                throw new Error("clipUuid is required for 'deleteClip' requestType");
+            }
+            return createToolStructuredContent(await deleteClip(args.clipUuid, requestModifiers, sessionId));
+        }
     }
-    return {
-        content: [{ type: "text", text: JSON.stringify(ret) }],
-    };
+    return createToolStructuredContent({ error: "Invalid requestType" });
 };
 export function createTool(server) {
-    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
 }

package/dist/tools/door-tool.js

@@ -0,0 +1,66 @@
+import { getDoorControllerRules, createDoorControllerRule, getDoorPolicies, createDoorPolicy, } from "../api/door-tool-api.js";
+import { DoorToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/door-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "door-tool";
+const TOOL_DESCRIPTION = `
+This tool manages Rhombus door controller rules and door policies.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${DoorToolRequestType.GET_DOOR_CONTROLLER_RULES}: Get all rules for a specific door controller. Requires doorControllerUuid.
+- ${DoorToolRequestType.CREATE_DOOR_CONTROLLER_RULE}: Create a new rule for a door controller. Requires doorControllerUuid and ruleConfig (JSON string).
+- ${DoorToolRequestType.GET_DOOR_POLICIES}: Get all door alert policies in the organization.
+- ${DoorToolRequestType.CREATE_DOOR_POLICY}: Create a new door policy. Requires policyName and policyConfig (JSON string).
+
+Use the get-entity-tool to find door controller and access controlled door UUIDs.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case DoorToolRequestType.GET_DOOR_CONTROLLER_RULES: {
+                if (!args.doorControllerUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "doorControllerUuid is required for get-door-controller-rules." }));
+                }
+                const doorControllerRules = await getDoorControllerRules(args.doorControllerUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ doorControllerRules });
+            }
+            case DoorToolRequestType.CREATE_DOOR_CONTROLLER_RULE: {
+                if (!args.doorControllerUuid || !args.ruleConfig) {
+                    return createToolTextContent(JSON.stringify({ error: "doorControllerUuid and ruleConfig are required for create-door-controller-rule." }));
+                }
+                const config = JSON.parse(args.ruleConfig);
+                config.deviceUuid = args.doorControllerUuid;
+                const createdRule = await createDoorControllerRule(config, requestModifiers, sessionId);
+                return createToolStructuredContent({ createdRule });
+            }
+            case DoorToolRequestType.GET_DOOR_POLICIES: {
+                const doorPolicies = await getDoorPolicies(requestModifiers, sessionId);
+                return createToolStructuredContent({ doorPolicies });
+            }
+            case DoorToolRequestType.CREATE_DOOR_POLICY: {
+                if (!args.policyConfig) {
+                    return createToolTextContent(JSON.stringify({ error: "policyConfig is required for create-door-policy." }));
+                }
+                const config = JSON.parse(args.policyConfig);
+                if (args.policyName)
+                    config.name = args.policyName;
+                const createdPolicy = await createDoorPolicy(config, requestModifiers, sessionId);
+                return createToolStructuredContent({ createdPolicy });
+            }
+        }
+    }
+    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);
+}