rhombus-node-mcp 0.1.55 → 0.1.57

package/dist/tools-console/video-walls-tool.js

@@ -1,4 +1,4 @@
-import { getVideoWalls, handleCreateVideoWallRequest, } from "../api/create-tool-api.js";
+import { computeGridSettings, deleteVideoWall, findVideoWall, getVideoWalls, handleCreateVideoWallRequest, updateVideoWall, } from "../api/create-tool-api.js";
 import { OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/video-walls-tool-types.js";
 import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
 const TOOL_NAME = "video-walls-tool";
@@ -6,36 +6,110 @@ const TOOL_DESCRIPTION = `
 This tool interacts with Rhombus video walls. Rhombus video walls are a collection of camera feeds combined into a single view,
 allowing users to monitor multiple cameras.
 
+It has the following modes of operation, determined by the "requestType" parameter:
+- 'list': List all video walls in the organization.
+- 'create': Create a new video wall. Requires videoWallCreateOptions with a displayName and a deviceList of camera UUIDs (use get-entity-tool or location-tool to resolve camera UUIDs first). Returns the new video wall's uuid.
+- 'update': Rename a video wall and/or change which cameras it shows. Requires videoWallUuid plus displayName and/or deviceList.
+- 'delete': Delete a video wall. Requires videoWallUuid.
+
 The layout of created video walls is automatically determined by the number of cameras in video wall settings "numVisibleDevicesAtOnce".
 `;
 const TOOL_HANDLER = async (args, extra) => {
-    const { requestType, videoWallCreateOptions } = args;
+    const { requestType, videoWallCreateOptions, videoWallUuid, displayName, deviceList } = args;
     const { requestModifiers, sessionId } = extractFromToolExtra(extra);
-    switch (requestType) {
-        case "create":
-            if (!videoWallCreateOptions) {
-                return createToolTextContent(JSON.stringify({
-                    error: "videoWallCreateOptions is required. Please try again.",
-                }));
+    try {
+        switch (requestType) {
+            case "create": {
+                if (!videoWallCreateOptions) {
+                    return createToolTextContent("videoWallCreateOptions is required for 'create'.");
+                }
+                return createToolStructuredContent(await handleCreateVideoWallRequest(videoWallCreateOptions, requestModifiers, sessionId));
+            }
+            case "list":
+                return createToolStructuredContent(await getVideoWalls(requestModifiers, sessionId));
+            case "update": {
+                if (!videoWallUuid) {
+                    return createToolTextContent("videoWallUuid is required for 'update'.");
+                }
+                if (!displayName?.trim() && !deviceList) {
+                    return createToolTextContent("'update' needs at least one of displayName or deviceList — both were empty, so there is nothing to change.");
+                }
+                if (deviceList && deviceList.length === 0) {
+                    return createToolTextContent("RETRYABLE — nothing was changed. deviceList was an empty array, which would leave the video wall with no cameras. Pass the full set of camera uuids the wall should show, or use 'delete' to remove the wall.");
+                }
+                // api2's updateVideoWalls REPLACES the whole wall object, so sending
+                // only the changed field would blank the rest.
+                const existing = await findVideoWall(videoWallUuid, requestModifiers, sessionId);
+                if (!existing) {
+                    return createToolTextContent(`No video wall in this organization has the uuid "${videoWallUuid}". Use requestType 'list' to see the walls that exist — do not guess a uuid.`);
+                }
+                const existingDevices = existing.deviceList?.filter((uuid) => !!uuid) ?? [];
+                const nextDevices = deviceList ?? existingDevices;
+                const existingSettings = (existing.settings ?? {});
+                const { updated, warningMsg } = await updateVideoWall({
+                    uuid: videoWallUuid,
+                    displayName: displayName?.trim() || existing.displayName || undefined,
+                    deviceList: nextDevices,
+                    orgUuid: existing.orgUuid ?? undefined,
+                    othersCanEdit: existing.othersCanEdit ?? undefined,
+                    shared: existing.shared ?? undefined,
+                    settings: {
+                        ...existingSettings,
+                        // The grid is a preset chosen by camera count, so a wall that
+                        // grew would otherwise keep a layout too small to show the new
+                        // cameras at all.
+                        ...computeGridSettings(nextDevices.length),
+                    },
+                }, requestModifiers, sessionId);
+                const removed = existingDevices.filter(uuid => !nextDevices.includes(uuid));
+                const added = nextDevices.filter(uuid => !existingDevices.includes(uuid));
+                const changes = [];
+                if (added.length > 0)
+                    changes.push(`added ${added.length}`);
+                if (removed.length > 0)
+                    changes.push(`removed ${removed.length}`);
+                return createToolStructuredContent({
+                    updated,
+                    warningMsg,
+                    note: deviceList
+                        ? `The wall now shows ${nextDevices.length} camera(s)${changes.length > 0 ? ` (${changes.join(", ")})` : ""}, and its grid layout was resized to match.`
+                        : `Renamed to "${displayName?.trim()}". Its cameras are unchanged.`,
+                });
             }
-            return createToolStructuredContent(await handleCreateVideoWallRequest(videoWallCreateOptions, requestModifiers, sessionId));
-        case "list":
-            return createToolStructuredContent(await getVideoWalls(requestModifiers, sessionId));
-        default:
+            case "delete": {
+                if (!videoWallUuid) {
+                    return createToolTextContent("videoWallUuid is required for 'delete'.");
+                }
+                const existing = await findVideoWall(videoWallUuid, requestModifiers, sessionId);
+                if (!existing) {
+                    return createToolTextContent(`No video wall in this organization has the uuid "${videoWallUuid}". Use requestType 'list' to see the walls that exist.`);
+                }
+                const { deleted, warningMsg } = await deleteVideoWall(videoWallUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    deleted,
+                    warningMsg,
+                    note: (existing.numShares ?? 0) > 0
+                        ? `Deleted "${existing.displayName ?? videoWallUuid}". It had ${existing.numShares} active share(s), which no longer work.`
+                        : `Deleted "${existing.displayName ?? videoWallUuid}". Deleting a wall does not affect the cameras that were on it.`,
+                });
+            }
+        }
+    }
+    catch (error) {
+        return createToolStructuredContent({
+            error: error instanceof Error ? error.message : "Unknown error",
+        });
     }
-    return {
-        content: [
-            {
-                type: "text",
-                text: "Invalid entity type. Please try again.",
-            },
-        ],
-    };
+    // Must carry structuredContent (or isError) — this tool registers an
+    // outputSchema, and the SDK replaces a bare text result with an opaque -32602.
+    return createToolTextContent("Invalid requestType. Valid values are: list, create, update, delete.");
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "Video Walls",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: false, destructiveHint: true },
     }, TOOL_HANDLER);
 }

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

@@ -8,6 +8,20 @@ export const ANOMALY_RULES = [
     "impossible_travel",
     "area_novelty",
 ];
+/**
+ * Description shared by the three access-anomaly tools (OnGuard / Elements /
+ * NetBox), which differ only in vendor. Kept short because tool descriptions
+ * are billed on every LLM call even while deferred, and this text is
+ * duplicated across all three siblings; rule detail and triage guidance live
+ * on the arguments below. See PERF_MASTER_PLAN P2 #4a.
+ */
+export function buildAccessAnomalyToolDescription(vendor) {
+    return `
+Scans ${vendor} access events over a time window and flags anomalous badge activity. Use for "find unusual badge activity", "anything suspicious in access this week", or proactive access review.
+
+Runs deterministic rules — a lost/suspended badge was used, access granted but no entry made (possible tailgating), off-hours entry, impossible travel between areas, and first-ever entry to an area — and returns ranked findings (high severity first) with cardholderName, the rule, severity, datetime, area, the camera deviceUuid, a plain-language rationale, and clip/still hints.
+`;
+}
 export const TOOL_ARGS = {
     area: z.string().nullable().describe("Optional: restrict analysis to events entering this area (full-text)."),
     locationUuids: z
@@ -19,7 +33,8 @@ export const TOOL_ARGS = {
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
         .nullable()
-        .describe("Start of the window to analyze (inclusive). " + ISOTimestampFormatDescription),
+        .describe('Start of the window to analyze (inclusive). Resolve relative phrasing like "this week" with time-tool first, then pass ISO 8601 here. ' +
+        ISOTimestampFormatDescription),
     endTime: z
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
@@ -28,7 +43,12 @@ export const TOOL_ARGS = {
     rules: z
         .array(z.enum(ANOMALY_RULES))
         .nullable()
-        .describe("Which rules to run; default all. Options: lost_or_inactive_badge, entry_not_made, off_hours, impossible_travel, area_novelty."),
+        .describe("Which rules to run; default all. Options: lost_or_inactive_badge (a non-active badge — lost or suspended — was used), " +
+        "entry_not_made (access granted but no entry made, possible tailgating), off_hours (entry outside business hours, configurable), " +
+        "impossible_travel (one cardholder at two different areas seconds apart), area_novelty (a cardholder's first-ever entry to an area vs their prior history; needs a baseline window). " +
+        "This tool is a triage aid: present findings grouped by severity, and for the notable ones call camera-tool " +
+        '(requestType "image", cameraUuid = finding.deviceUuid, timestampISO = the finding\'s time — convert finding.timestampMs with time-conversion-tool) ' +
+        'and/or clips-tool ("createClip" using finding.clipHint) IN PARALLEL so a human can confirm. Do not assert wrongdoing; surface the evidence.'),
     baselineDays: z
         .number()
         .nullable()

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

@@ -4,12 +4,34 @@ export var AccessControlRequestType;
 (function (AccessControlRequestType) {
     AccessControlRequestType["UNLOCK_DOOR"] = "unlock-door";
     AccessControlRequestType["GET_GROUPS"] = "get-groups";
+    AccessControlRequestType["CREATE_GROUP"] = "create-group";
+    AccessControlRequestType["UPDATE_GROUP"] = "update-group";
+    AccessControlRequestType["DELETE_GROUP"] = "delete-group";
+    AccessControlRequestType["ADD_USERS_TO_GROUP"] = "add-users-to-group";
+    AccessControlRequestType["REMOVE_USERS_FROM_GROUP"] = "remove-users-from-group";
     AccessControlRequestType["GET_CREDENTIALS_BY_USER"] = "get-credentials-by-user";
+    AccessControlRequestType["ASSIGN_CREDENTIAL"] = "assign-credential";
+    AccessControlRequestType["REVOKE_CREDENTIAL"] = "revoke-credential";
+    AccessControlRequestType["SUSPEND_CREDENTIAL"] = "suspend-credential";
+    AccessControlRequestType["UNSUSPEND_CREDENTIAL"] = "unsuspend-credential";
+    AccessControlRequestType["DELETE_CREDENTIAL"] = "delete-credential";
+    AccessControlRequestType["UPDATE_CREDENTIAL_NOTE"] = "update-credential-note";
     AccessControlRequestType["GET_LOCKDOWN_PLANS"] = "get-lockdown-plans";
+    AccessControlRequestType["RENAME_LOCKDOWN_PLAN"] = "rename-lockdown-plan";
+    AccessControlRequestType["DELETE_LOCKDOWN_PLAN"] = "delete-lockdown-plan";
     AccessControlRequestType["ACTIVATE_LOCKDOWN"] = "activate-lockdown";
     AccessControlRequestType["DEACTIVATE_LOCKDOWN"] = "deactivate-lockdown";
+    /**
+     * Reads door schedule EXCEPTIONS, not schedules — the name is retained
+     * because it is the published request type. Prefer door-schedule-exception-tool
+     * for anything beyond a location-scoped list, and schedule-tool for schedules
+     * themselves.
+     */
     AccessControlRequestType["GET_DOOR_SCHEDULES"] = "get-door-schedules";
     AccessControlRequestType["GET_ACCESS_GRANTS"] = "get-access-grants";
+    AccessControlRequestType["CREATE_ACCESS_GRANT"] = "create-access-grant";
+    AccessControlRequestType["UPDATE_ACCESS_GRANT"] = "update-access-grant";
+    AccessControlRequestType["DELETE_ACCESS_GRANT"] = "delete-access-grant";
     AccessControlRequestType["GET_REMOTE_UNLOCK_USERS"] = "get-remote-unlock-users";
 })(AccessControlRequestType || (AccessControlRequestType = {}));
 export const TOOL_ARGS = {
@@ -29,7 +51,59 @@ export const TOOL_ARGS = {
     lockdownPlanUuid: z
         .string()
         .nullable()
-        .describe("The UUID of the lockdown plan. Required for 'activate-lockdown' and 'deactivate-lockdown'."),
+        .describe("The UUID of the lockdown plan. Required for 'activate-lockdown', 'deactivate-lockdown', 'rename-lockdown-plan' and 'delete-lockdown-plan'."),
+    groupUuid: z
+        .string()
+        .nullable()
+        .describe("The UUID of the access control group. Required for 'update-group', 'delete-group', 'add-users-to-group' and 'remove-users-from-group'. Get it from 'get-groups' — do not guess one."),
+    groupName: z
+        .string()
+        .nullable()
+        .describe("Name of the access control group. Required for 'create-group'; for 'update-group' it is the new name (omit to leave it unchanged). Also the new name for 'rename-lockdown-plan'."),
+    groupDescription: z
+        .string()
+        .nullable()
+        .describe("Description of the access control group. Optional for 'create-group' and 'update-group'."),
+    userUuids: z
+        .array(z.string())
+        .nullable()
+        .describe("User UUIDs. Required for 'add-users-to-group' and 'remove-users-from-group'; optional for 'create-group' to seed the initial members. Resolve names and emails to UUIDs with user-tool first — never guess a user UUID, because granting the wrong person physical door access is not something the user can see from the response."),
+    credentialUuid: z
+        .string()
+        .nullable()
+        .describe("The UUID of the access control credential. Required for 'revoke-credential', 'suspend-credential', 'unsuspend-credential', 'delete-credential' and 'update-credential-note'. Get it from 'get-credentials-by-user'."),
+    credentialHexValue: z
+        .string()
+        .nullable()
+        .describe("The hex value printed on / encoded in a physical badge or fob. Required for 'assign-credential'. The credential must already exist in the org as an unassigned credential; this attaches it to a user."),
+    credentialNote: z
+        .string()
+        .nullable()
+        .describe("Free-text note to store on the credential. Required for 'update-credential-note'."),
+    accessGrantUuid: z
+        .string()
+        .nullable()
+        .describe("The UUID of the location access grant. Required for 'update-access-grant' and 'delete-access-grant'. Get it from 'get-access-grants'."),
+    accessGrantName: z
+        .string()
+        .nullable()
+        .describe("Name for the access grant. Required for 'create-access-grant'; for 'update-access-grant' it is the new name (omit to leave it unchanged)."),
+    doorUuids: z
+        .array(z.string())
+        .nullable()
+        .describe("Access controlled door UUIDs the grant provides access to. Required for 'create-access-grant'. For 'update-access-grant' this REPLACES the grant's current door list rather than adding to it, so include the doors being kept; omit to leave the doors unchanged. Get UUIDs from get-entity-tool with entityType ACCESS_CONTROL_DOOR."),
+    groupUuids: z
+        .array(z.string())
+        .nullable()
+        .describe("Access control group UUIDs the grant applies to. For 'update-access-grant' this REPLACES the grant's current group list; omit to leave it unchanged."),
+    scheduleUuid: z
+        .string()
+        .nullable()
+        .describe("UUID of the schedule limiting when the grant applies. Optional. Resolve schedule names to UUIDs with schedule-tool — never invent one."),
+    confirmDelete: z
+        .boolean()
+        .nullable()
+        .describe("Required to be true for 'delete-group', 'delete-credential', 'delete-access-grant' and 'delete-lockdown-plan'. All four remove physical access or the ability to restore it, so they refuse without explicit confirmation from the user."),
     includeFields: INCLUDE_FIELDS_ARG,
     filterBy: FILTER_BY_ARG,
 };
@@ -116,5 +190,46 @@ export const OUTPUT_SCHEMA = z.object({
     })
         .optional()
         .describe("Users who can remotely unlock doors at a location, grouped by permission group. Always present the COMPLETE list of all users to the end user."),
+    created: z
+        .object({
+        success: z.boolean().optional(),
+        uuid: z.string().optional(),
+        memberCount: z.number().optional(),
+    })
+        .optional()
+        .describe("Result of a create request."),
+    updated: z
+        .object({
+        success: z.boolean().optional(),
+        uuid: z.string().optional(),
+        userCount: z.number().optional(),
+    })
+        .optional()
+        .describe("Result of an update / membership-change request."),
+    deleted: z
+        .object({ success: z.boolean().optional(), uuid: z.string().optional() })
+        .optional()
+        .describe("Result of a delete request."),
+    credentialChange: z
+        .object({
+        success: z.boolean().optional(),
+        uuid: z.string().optional(),
+        userUuid: z.string().optional(),
+        action: z.string().optional(),
+    })
+        .optional()
+        .describe("Result of a credential state change."),
+    doorsWithoutLicense: z
+        .array(z.string())
+        .optional()
+        .describe("Doors named in an access grant whose access-control license is expired or unassigned. The grant saved, but these doors grant NOBODY access until their license is fixed — always report them."),
+    note: z
+        .string()
+        .optional()
+        .describe("A caveat about this result that the user needs to be told."),
+    warningMsg: z
+        .string()
+        .optional()
+        .describe("A warning from the Rhombus API — the call succeeded, but with a caveat."),
     error: z.string().optional().describe("An error message if the request failed."),
 });

package/dist/types/alarm-monitoring-tool-types.js

@@ -5,6 +5,11 @@ export var AlarmMonitoringRequestType;
     AlarmMonitoringRequestType["ORG_STATUS"] = "org-status";
     AlarmMonitoringRequestType["GET_THREAT_CASES"] = "get-threat-cases";
     AlarmMonitoringRequestType["LOCATION_STATUS"] = "location-status";
+    AlarmMonitoringRequestType["ENABLE_MONITORING"] = "enable-monitoring";
+    AlarmMonitoringRequestType["DISABLE_MONITORING"] = "disable-monitoring";
+    AlarmMonitoringRequestType["DISMISS_THREAT_CASE"] = "dismiss-threat-case";
+    AlarmMonitoringRequestType["CANCEL_THREAT_CASE"] = "cancel-threat-case";
+    AlarmMonitoringRequestType["ESCALATE_THREAT_CASE"] = "escalate-threat-case";
 })(AlarmMonitoringRequestType || (AlarmMonitoringRequestType = {}));
 export const TOOL_ARGS = {
     requestType: z
@@ -13,7 +18,19 @@ export const TOOL_ARGS = {
     locationUuid: z
         .string()
         .nullable()
-        .describe("Location UUID. Required for 'location-status'."),
+        .describe("Location UUID. Required for 'location-status', 'enable-monitoring' and 'disable-monitoring'."),
+    pin: z
+        .string()
+        .nullable()
+        .describe("The location's alarm PIN, required for 'enable-monitoring' and 'disable-monitoring'. Ask the user for it; never guess one and never repeat it back in your response."),
+    threatCaseUuid: z
+        .string()
+        .nullable()
+        .describe("UUID of a threat case. Required for 'dismiss-threat-case', 'cancel-threat-case' and 'escalate-threat-case'. Get it from 'get-threat-cases' — do not guess one."),
+    confirmAction: z
+        .boolean()
+        .nullable()
+        .describe("Required to be true for 'disable-monitoring' and 'escalate-threat-case'. Disabling monitoring stops a location being watched, and escalating dispatches a real alarm response, so both refuse without explicit confirmation from the user."),
     startTimeMs: z
         .number()
         .nullable()
@@ -56,5 +73,29 @@ export const OUTPUT_SCHEMA = z.object({
         .optional()
         .describe("List of alarm monitoring threat cases"),
     locationDetail: LocationMonitoringStatusSchema.optional().describe("Detailed alarm monitoring status for a single location"),
+    monitoringChange: z
+        .object({
+        success: z.boolean().optional(),
+        locationUuid: z.string().optional(),
+        enabled: z.boolean().optional(),
+    })
+        .optional()
+        .describe("Result of 'enable-monitoring' / 'disable-monitoring'."),
+    threatCaseChange: z
+        .object({
+        success: z.boolean().optional(),
+        uuid: z.string().optional(),
+        action: z.string().optional(),
+    })
+        .optional()
+        .describe("Result of a threat case state change."),
+    note: z
+        .string()
+        .optional()
+        .describe("A caveat about this result that the user needs to be told."),
+    warningMsg: z
+        .string()
+        .optional()
+        .describe("A warning from the Rhombus API — the call succeeded, but with a caveat."),
     error: z.string().optional().describe("An error message if the request failed."),
 });

package/dist/types/badge-timeline-tool-types.js

@@ -1,10 +1,24 @@
 import { z } from "zod";
 import { createUuidSchema } from "../types.js";
 import { ISOTimestampFormatDescription } from "../utils/timestampInput.js";
+/**
+ * Description shared by the three badge-timeline tools (OnGuard / Elements /
+ * NetBox), which differ only in vendor. Kept short because tool descriptions
+ * are billed on every LLM call even while deferred, and this text is
+ * duplicated across all three siblings; the how-to-present guidance lives on
+ * the arguments below. See PERF_MASTER_PLAN P2 #4a.
+ */
+export function buildBadgeTimelineToolDescription(vendor) {
+    return `
+Reconstructs one person's movements through a building from their ${vendor} badge taps. Use this for incident reconstruction / "follow the badge" requests, e.g. "reconstruct Eve's movements yesterday" or "where did this cardholder go".
+
+Returns the cardholder's badge taps in CHRONOLOGICAL order (oldest first) — datetime, the area entered, deviceUuid of the camera at that door, clip/still hints, and gapToNextSeconds (a large gap means unobserved movement between doors) — plus a "path" array summarizing the areas traversed in order.
+`;
+}
 export const TOOL_ARGS = {
     cardholderQuery: z
         .string()
-        .describe('The cardholder (person) to reconstruct, full-text name match, e.g. "Eve" or "Eve Adams".'),
+        .describe('The cardholder (person) to reconstruct, full-text name match, e.g. "Eve" or "Eve Adams". If the response contains "ambiguousCardholders" the query matched more than one person — ask the user which one before trusting the timeline.'),
     locationUuids: z
         .array(createUuidSchema())
         .nullable()
@@ -13,7 +27,8 @@ export const TOOL_ARGS = {
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
         .nullable()
-        .describe("Start of the window (inclusive). " + ISOTimestampFormatDescription),
+        .describe('Start of the window (inclusive). Resolve relative phrasing like "yesterday" with time-tool first, then pass ISO 8601 here. ' +
+        ISOTimestampFormatDescription),
     endTime: z
         .string()
         .datetime({ message: "Invalid datetime string. Expected ISO 8601 format.", offset: true })
@@ -22,7 +37,7 @@ export const TOOL_ARGS = {
     clipPaddingSeconds: z
         .number()
         .nullable()
-        .describe("Seconds of video before/after each badge tap to include in the clip hint (default 15)."),
+        .describe("Seconds of video before/after each badge tap to include in the clip hint (default 15). To show the movement visually after this returns: for each stop (or the key transitions) call camera-tool (requestType \"image\", cameraUuid = stop.deviceUuid, timestampISO = the stop's time — convert stop.timestampMs with time-conversion-tool) for a still, and/or clips-tool (requestType \"createClip\", using stop.clipHint) for video. Issue those per-stop media calls IN PARALLEL, then present the timeline as a chronological narrative."),
     limit: z.number().nullable().describe("Maximum badge taps to include (default 200)."),
     timeZone: z
         .string()

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

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { SCHEDULE_CONFIGS_EXAMPLE } from "./create-camera-policy-tool-types.js";
+export var CameraPolicyToolRequestType;
+(function (CameraPolicyToolRequestType) {
+    CameraPolicyToolRequestType["LIST"] = "list";
+    CameraPolicyToolRequestType["GET"] = "get";
+    CameraPolicyToolRequestType["UPDATE"] = "update";
+    CameraPolicyToolRequestType["DELETE"] = "delete";
+    CameraPolicyToolRequestType["ASSIGN_CAMERAS"] = "assign-cameras";
+    CameraPolicyToolRequestType["UNASSIGN_CAMERAS"] = "unassign-cameras";
+})(CameraPolicyToolRequestType || (CameraPolicyToolRequestType = {}));
+export const TOOL_ARGS = {
+    requestType: z
+        .nativeEnum(CameraPolicyToolRequestType)
+        .describe("The type of camera policy operation to perform."),
+    policyUuid: z
+        .string()
+        .nullable()
+        .describe("The UUID of the camera policy. Required for every requestType except 'list'."),
+    name: z
+        .string()
+        .nullable()
+        .describe("A new name for the policy. Only used by 'update'; omit to leave the name unchanged."),
+    description: z
+        .string()
+        .nullable()
+        .describe("A new description for the policy. Only used by 'update'; omit to leave it unchanged."),
+    scheduleConfigs: z
+        .string()
+        .nullable()
+        .describe(`Only used by 'update'. JSON string array of {"scheduleUuid","activities"} objects — e.g. ` +
+        `${SCHEDULE_CONFIGS_EXAMPLE}. Resolve schedule names to UUIDs with schedule-tool first; ` +
+        `never invent a scheduleUuid. Passing this REPLACES all of the policy's existing ` +
+        `schedule triggers, so include every window the policy should keep, not just the new ` +
+        `one. Omit to leave the triggers unchanged.`),
+    cameraUuids: z
+        .string()
+        .nullable()
+        .describe("Comma-separated camera UUIDs. Required for 'assign-cameras' and 'unassign-cameras'. " +
+        "Resolve camera names to UUIDs with get-entity-tool first."),
+    confirmDeleteInUse: z
+        .boolean()
+        .nullable()
+        .describe("Only for 'delete'. Deleting a policy that cameras are still assigned to leaves those " +
+        "cameras with no policy, so 'delete' refuses by default and lists them. Set true to " +
+        "delete anyway, after telling the user which cameras are affected."),
+};
+const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+const SCHEDULED_TRIGGER_OUTPUT = z.object({
+    scheduleUuid: z.string().optional(),
+    scheduleName: z.string().optional(),
+    scheduleWindows: z
+        .array(z.string())
+        .optional()
+        .describe('When the schedule is active, e.g. ["Monday 09:00 – Monday 17:00"].'),
+    activities: z
+        .array(z.string())
+        .optional()
+        .describe("The activities that trigger an alert during this schedule."),
+});
+const POLICY_OUTPUT = z.object({
+    uuid: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    defaultActivities: z
+        .array(z.string())
+        .optional()
+        .describe("Activities that trigger at all times, outside any schedule."),
+    scheduledTriggers: z.array(SCHEDULED_TRIGGER_OUTPUT).optional(),
+    assignedCameraCount: z
+        .number()
+        .optional()
+        .describe("How many cameras this policy is assigned to. Pre-computed so the count never has to be derived by scanning assignedCameras."),
+    assignedCameras: z
+        .array(z.object({ uuid: z.string().optional(), name: z.string().optional() }))
+        .optional()
+        .describe("The cameras this policy is assigned to."),
+});
+export const OUTPUT_SCHEMA = z.object({
+    policies: z.array(POLICY_OUTPUT).optional().describe("All camera policies in the organization."),
+    policy: POLICY_OUTPUT.optional().describe("A single camera policy."),
+    updated: z
+        .object({ success: z.boolean().optional(), policyUuid: z.string().optional() })
+        .optional(),
+    deleted: z
+        .object({ success: z.boolean().optional(), policyUuid: z.string().optional() })
+        .optional(),
+    assigned: z
+        .object({
+        success: z.boolean().optional(),
+        policyUuid: z.string().optional(),
+        cameraCount: z.number().optional(),
+    })
+        .optional(),
+    note: z
+        .string()
+        .optional()
+        .describe("A caveat about this result that the user needs to be told."),
+    warningMsg: z
+        .string()
+        .optional()
+        .describe("A warning from the Rhombus API — the call succeeded, but with a caveat."),
+    error: z.string().optional().describe("An error message if the request failed."),
+});

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

@@ -220,7 +220,27 @@ export const BASE_TOOL_ARGS = {
         .describe(`
       the timestamp for the image. This will default to 5 minutes before the current time. You can also call time-tool to parse the user's time description.
       ` + ISOTimestampFormatDescription),
-    requestType: z.enum(["image", "get-settings", "get-media-uris", "get-ai-thresholds"]),
+    requestType: z
+        .enum(["image", "get-settings", "get-media-uris", "get-ai-thresholds"])
+        .describe(`Which camera action to run: "image" (fetch a frame), "get-settings" (current device configuration), "get-media-uris" (live-stream and VOD URLs), "get-ai-thresholds" (AI detection thresholds).
+
+**AUTOMATIC SNAPSHOT FOR IMAGE QUALITY ISSUES** — when a user mentions camera image quality (darkness, brightness, blur, washed out, "doesn't look great", "fix the image", etc.), you MUST IMMEDIATELY:
+1. Call camera-tool with requestType "image" to capture a snapshot WITHOUT asking first.
+2. Analyze the image to identify quality issues.
+3. Call camera-tool with requestType "get-settings" to check current camera settings.
+4. Propose specific setting changes based on your analysis (store the exact values you plan to change, e.g. img_brightness, wdr_strength).
+5. When the user confirms ("yes", "confirm", "fix it", "apply", "go ahead", "ok", etc.), call update-tool with those stored settings — see update-tool's description for the confirmation flow. NEVER skip the update-tool call.
+
+**VISUAL-FEATURE CAMERA FILTERING** — when the user asks for cameras filtered by what they can see (indoors/outdoors, "facing the street", "with a view of X", parking lot, entrance), you MUST:
+1. First get the camera list via get-entity-tool or location-tool.
+2. Then call camera-tool with requestType "image" for EACH candidate camera (in PARALLEL).
+3. Analyze each image to determine if it meets the user's criteria.
+4. Return only the cameras that match.`),
+    detail: z
+        .enum(["core", "full"])
+        .nullish()
+        .transform((v) => v ?? "core")
+        .describe("For requestType 'get-settings' only. 'core' (default) elides bulky geometry/table sub-configs (metering tables, ROI polygons, PTZ/motor config) and oversized values, keeping the settings you can read and change (image/video/exposure/storage). Pass 'full' for the complete raw config."),
     cropX: z
         .number()
         .min(0)
@@ -257,3 +277,62 @@ export const BASE_TOOL_ARGS = {
         .describe("For requestType 'image' only. Ratio to shrink the image pixels by (default 10). Use a smaller value (e.g. 1-3) when zooming into a crop to keep detail."),
 };
 const BASE_TOOL_ARGS_SCHEMA = z.object(BASE_TOOL_ARGS);
+// Output schema — registered so the filtering proxy can project results and
+// generate the includeFields path catalog. All fields optional: which subset
+// appears depends on requestType. Every handler return must carry
+// structuredContent (or isError: true) once this is registered — the SDK
+// otherwise replaces the real message with an opaque -32602 (see CLAUDE.md).
+export const OUTPUT_SCHEMA = {
+    // asked for a camera without saying which
+    needUserInput: z.boolean().optional(),
+    commandForUser: z.string().optional(),
+    // requestType: "image"
+    success: z.boolean().optional(),
+    status: z.string().optional(),
+    cameraUuid: z.string().optional(),
+    timestampMs: z.number().optional(),
+    cropApplied: z
+        .object({
+        x: z.number().nullable().optional(),
+        y: z.number().nullable().optional(),
+        width: z.number().nullable().optional(),
+        height: z.number().nullable().optional(),
+    })
+        .nullable()
+        .optional()
+        .describe("The crop actually applied to the returned frame, if any"),
+    // requestType: "get-settings" — the faceted config is free-form (~150 fields
+    // per facet), so it is an open record; project with paths like
+    // "config.videoFacetSettings".
+    config: z.record(z.string(), z.unknown()).optional(),
+    daysInCloud: z.number().optional(),
+    daysOnCamera: z.number().optional(),
+    cloudArchiveDays: z.number().nullable().optional(),
+    // requestType: "get-media-uris" (subset of Camera_GetMediaUrisWSResponse)
+    lanCheckUrls: z.array(z.string().nullable()).nullable().optional(),
+    lanLiveH264Uris: z.array(z.string().nullable()).nullable().optional(),
+    lanLiveM3u8Uris: z.array(z.string().nullable()).nullable().optional(),
+    lanLiveMpdUris: z.array(z.string().nullable()).nullable().optional(),
+    lanLiveOpusUris: z.array(z.string().nullable()).nullable().optional(),
+    lanVodM3u8UrisTemplates: z.array(z.string().nullable()).nullable().optional(),
+    lanVodMpdUrisTemplates: z.array(z.string().nullable()).nullable().optional(),
+    wanLiveH264Uri: z.string().nullable().optional(),
+    wanLiveM3u8Uri: z.string().nullable().optional(),
+    wanLiveMpdUri: z.string().nullable().optional(),
+    wanLiveOpusUri: z.string().nullable().optional(),
+    wanVodH264UriTemplate: z.string().nullable().optional(),
+    wanVodM3u8UriTemplate: z.string().nullable().optional(),
+    wanVodMpdUriTemplate: z.string().nullable().optional(),
+    // requestType: "get-ai-thresholds" (Camera_GetCameraAIThresholdsWSResponse)
+    consecutiveHumanFilter: z.number().nullable().optional(),
+    consecutiveVehicleFilter: z.number().nullable().optional(),
+    faceConfidenceThreshold: z.number().nullable().optional(),
+    faceMatchConfidenceThreshold: z.number().nullable().optional(),
+    humanConfidenceThreshold: z.number().nullable().optional(),
+    lprConfidenceThreshold: z.number().nullable().optional(),
+    vehicleConfidenceThreshold: z.number().nullable().optional(),
+    maxEventDurationMs: z.number().nullable().optional(),
+    // api2's success-with-caveat channel; in ALWAYS_PROTECTED_FIELDS so a
+    // projection cannot strip it
+    warningMsg: z.string().nullable().optional(),
+};