rhombus-node-mcp 0.1.26 → 0.1.27

package/dist/api/door-schedule-exception-tool-api.js

@@ -45,14 +45,15 @@ function buildDateRangeFilter(filter) {
         localEndDateRangeEnd,
     };
 }
-async function verifyExceptionConfig(exception, requestModifiers, sessionId) {
+async function verifyExceptionConfig(exception, options, requestModifiers, sessionId) {
     const verified = {
         ...exception,
     };
-    const cleanedDoorUuids = (Array.isArray(exception.doorUuids)
-        ? exception.doorUuids.filter((doorUuid) => !!doorUuid)
-        : []) ?? [];
-    if (cleanedDoorUuids.length > 0) {
+    const doorUuidsProvided = Array.isArray(exception.doorUuids);
+    const cleanedDoorUuids = doorUuidsProvided
+        ? (exception.doorUuids?.filter((doorUuid) => !!doorUuid) ?? [])
+        : undefined;
+    if (cleanedDoorUuids !== undefined) {
         verified.doorUuids = cleanedDoorUuids;
     }
     if ((!Array.isArray(exception.intervals) || exception.intervals.length === 0) &&
@@ -67,27 +68,33 @@ async function verifyExceptionConfig(exception, requestModifiers, sessionId) {
             },
         ];
     }
-    // construct locationToDoorsMap
-    const locationToDoorsMap = {};
-    if (cleanedDoorUuids.length > 0) {
-        const doors = await getAccessControlledDoors(requestModifiers, sessionId);
-        const doorsMap = await createUuidMap(doors.accessControlledDoors ?? [], "uuid");
-        for (const doorUuid of cleanedDoorUuids) {
-            const door = doorsMap.get(doorUuid);
-            const locationUuid = door?.locationUuid;
-            if (locationUuid) {
-                if (!locationToDoorsMap[locationUuid]) {
-                    locationToDoorsMap[locationUuid] = [];
+    // construct locationToDoorsMap only when doors are explicitly provided.
+    // For update, omitting doorUuids should preserve the existing map.
+    if (cleanedDoorUuids !== undefined) {
+        const locationToDoorsMap = {};
+        if (cleanedDoorUuids.length > 0) {
+            const doors = await getAccessControlledDoors(requestModifiers, sessionId);
+            const doorsMap = await createUuidMap(doors.accessControlledDoors ?? [], "uuid");
+            for (const doorUuid of cleanedDoorUuids) {
+                const door = doorsMap.get(doorUuid);
+                const locationUuid = door?.locationUuid;
+                if (locationUuid) {
+                    if (!locationToDoorsMap[locationUuid]) {
+                        locationToDoorsMap[locationUuid] = [];
+                    }
+                    locationToDoorsMap[locationUuid].push(doorUuid);
                 }
-                locationToDoorsMap[locationUuid].push(doorUuid);
             }
         }
+        verified.locationToDoorsMap = locationToDoorsMap;
+    }
+    else if (!options.isUpdate) {
+        verified.locationToDoorsMap = {};
     }
-    verified.locationToDoorsMap = locationToDoorsMap;
     return verified;
 }
 export async function createDoorScheduleException(exception, requestModifiers, sessionId) {
-    const normalizedException = await verifyExceptionConfig(exception, requestModifiers, sessionId);
+    const normalizedException = await verifyExceptionConfig(exception, { isUpdate: false }, requestModifiers, sessionId);
     const res = await postApi({
         route: "/accesscontrol/doorScheduleException/createExceptionV2",
         body: {
@@ -103,7 +110,7 @@ export async function createDoorScheduleException(exception, requestModifiers, s
     };
 }
 export async function updateDoorScheduleException(exception, requestModifiers, sessionId) {
-    const normalizedException = await verifyExceptionConfig(exception, requestModifiers, sessionId);
+    const normalizedException = await verifyExceptionConfig(exception, { isUpdate: true }, requestModifiers, sessionId);
     const res = await postApi({
         route: "/accesscontrol/doorScheduleException/updateExceptionV2",
         body: {

package/dist/tools/door-schedule-exception-tool.js

@@ -1,5 +1,5 @@
 import { createDoorScheduleException, deleteDoorScheduleException, findDoorScheduleExceptions, findDoorScheduleExceptionsForDoor, findDoorScheduleExceptionsForLocation, getDoorScheduleException, updateDoorScheduleException, } from "../api/door-schedule-exception-tool-api.js";
-import { DoorScheduleExceptionRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/door-schedule-exception-tool-types.js";
+import { CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA, DoorScheduleExceptionRequestType, OUTPUT_SCHEMA, TOOL_ARGS, UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA, } from "../types/door-schedule-exception-tool-types.js";
 import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
 const TOOL_NAME = "door-schedule-exception-tool";
 const TOOL_DESCRIPTION = `
@@ -9,6 +9,10 @@ If a lock/unlock exception is enabled, it will overwrite the existing lock/unloc
 A schedule exception allows you to create a custom schedule that is only active for the specified dates/times. 
 Once the date/time a schedule exception is set for passes, the original schedule will resume.
 
+Door schedule exceptions can be either expired or not expired. If its scheduled date is in the past, then it is expired.
+Users through the web console can toggle whether to see expired door schedule exceptions or not. Please mirror this behavior
+when responding to the user.
+
 It has the following modes of operation, determined by the "requestType" parameter:
 - ${DoorScheduleExceptionRequestType.CREATE_EXCEPTION}: Create a door schedule exception. Requires exception (DoorScheduleExceptionType object). If locationUuid is missing but doorUuids are provided, the tool will resolve the location automatically.
 - ${DoorScheduleExceptionRequestType.DELETE_EXCEPTION}: Delete a door schedule exception. Requires exceptionUuid.
@@ -38,7 +42,13 @@ const TOOL_HANDLER = async (args, _extra) => {
                         error: "exception is required for create-exception.",
                     }));
                 }
-                const created = await createDoorScheduleException(args.exception, requestModifiers, sessionId);
+                const parsedException = CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA.safeParse(args.exception);
+                if (!parsedException.success) {
+                    return createToolTextContent(JSON.stringify({
+                        error: parsedException.error.issues[0]?.message ?? "Invalid exception payload for create-exception.",
+                    }));
+                }
+                const created = await createDoorScheduleException(parsedException.data, requestModifiers, sessionId);
                 return createToolStructuredContent(created);
             }
             case DoorScheduleExceptionRequestType.DELETE_EXCEPTION: {
@@ -87,7 +97,14 @@ const TOOL_HANDLER = async (args, _extra) => {
                         error: "exception is required for update-exception.",
                     }));
                 }
-                const updated = await updateDoorScheduleException(args.exception, requestModifiers, sessionId);
+                const parsedException = UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA.safeParse(args.exception);
+                if (!parsedException.success) {
+                    return createToolTextContent(JSON.stringify({
+                        error: parsedException.error.issues[0]?.message ??
+                            "Invalid exception payload for update-exception.",
+                    }));
+                }
+                const updated = await updateDoorScheduleException(parsedException.data, requestModifiers, sessionId);
                 return createToolStructuredContent(updated);
             }
         }

package/dist/types/door-schedule-exception-tool-types.js

@@ -11,29 +11,29 @@ export var DoorScheduleExceptionRequestType;
     DoorScheduleExceptionRequestType["GET_EXCEPTION"] = "get-exception";
     DoorScheduleExceptionRequestType["UPDATE_EXCEPTION"] = "update-exception";
 })(DoorScheduleExceptionRequestType || (DoorScheduleExceptionRequestType = {}));
-export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z
+const DOOR_INTERVAL_SCHEMA = z.object({
+    localEndDateTime: z.string().nullable(),
+    localStartDateTime: z.string().nullable(),
+    state: z.enum(AccessControlledDoorStateEnumType),
+});
+const DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA = z
     .object({
-    createdAtMillis: z.number().nullable(),
-    defaultState: z.enum(AccessControlledDoorStateEnumType).nullable(),
-    description: z.string().nullable(),
+    uuid: z.string().nullable().optional(),
+    createdAtMillis: z.number().nullable().optional(),
+    defaultState: z.enum(AccessControlledDoorStateEnumType).nullable().optional(),
+    description: z.string().nullable().optional(),
     doorUuids: z.array(z.string().nullable()).nullable().optional(),
-    intervals: z
-        .array(z.object({
-        localEndDateTime: z.string().nullable(),
-        localStartDateTime: z.string().nullable(),
-        state: z.enum(AccessControlledDoorStateEnumType),
-    }))
-        .nullable(),
-    localEndDate: z.string().nullable(),
-    localStartDate: z.string().nullable(),
+    intervals: z.array(DOOR_INTERVAL_SCHEMA).nullable().optional(),
+    localEndDate: z.string().nullable().optional(),
+    localStartDate: z.string().nullable().optional(),
     locationToDoorsMap: z
         .record(z.string(), z.array(z.string().nullable()).nullable())
         .nullable()
         .optional(),
-    name: z.string().nullable(),
-    updatedAtMillis: z.number().nullable(),
-})
-    .superRefine((value, ctx) => {
+    name: z.string().nullable().optional(),
+    updatedAtMillis: z.number().nullable().optional(),
+});
+export const CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA.superRefine((value, ctx) => {
     if (!value.name) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -74,6 +74,36 @@ export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z
         });
     }
 });
+export const UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = DOOR_SCHEDULE_EXCEPTION_BASE_SCHEMA.superRefine((value, ctx) => {
+    if (!value.uuid) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception.uuid is required for update-exception.",
+            path: ["uuid"],
+        });
+    }
+    const hasMutableField = [
+        value.name,
+        value.description,
+        value.defaultState,
+        value.localStartDate,
+        value.localEndDate,
+        value.intervals,
+        value.doorUuids,
+        value.locationToDoorsMap,
+    ].some((field) => field !== undefined);
+    if (!hasMutableField) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "exception update must provide at least one mutable field (for example name, description, dates, intervals, doorUuids, or locationToDoorsMap).",
+            path: [],
+        });
+    }
+});
+export const DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA = z.union([
+    CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA,
+    UPDATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA,
+]);
 export const TOOL_ARGS = {
     requestType: z
         .nativeEnum(DoorScheduleExceptionRequestType)

package/package.json

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