rhombus-node-mcp 0.1.56 → 0.1.57

package/dist/tools-console/create-camera-policy-tool.js

@@ -1,141 +1,333 @@
 import { z } from "zod";
 import { createCameraPolicy } from "../api/create-camera-policy-tool-api.js";
-import { ApiPayloadSchema, OUTPUT_SCHEMA } from "../types/create-camera-policy-tool-types.js";
+import { ApiPayloadSchema, OUTPUT_SCHEMA, SCHEDULE_CONFIGS_EXAMPLE, SUGGESTED_CAMERA_ACTIVITIES, isEmptyScheduleConfigs, parseCameraUuids, parseScheduleConfigs, } from "../types/create-camera-policy-tool-types.js";
 import { postApi } from "../network/network.js";
 const TOOL_NAME = "create-camera-policy-tool";
 const TOOL_DESCRIPTION = `
-A tool for creating a camera policy that walks users through a multi-step process.
+A tool for creating a camera policy.
 
-The step begins with the user providing a policy name, description, and organization UUID.
-Then, the user is presented with a form to configure the schedules for the policy.
-Finally, the user is presented with a form to assign the policy to cameras.
+Preferred (single call): pass name, description, orgUuid, scheduleConfigs, and cameraUuids together — the tool creates the policy, configures its schedule triggers, and assigns the cameras all in one call. Omit policyUuid; it is created for you.
 
-Uses elicitation forms for rich user interaction.
+Legacy step-by-step: calling with only a subset of args advances one phase at a time (name/description/orgUuid to create → policyUuid+scheduleConfigs for schedules → policyUuid+cameraUuids for camera assignment).
+
+Errors are labelled: a "RETRYABLE" error means nothing was written and you should call again with corrected arguments; a "PARTIAL STATE" error means part of the policy now exists and you must stop and report it.
 `;
+// All args are optional: each step of the flow uses a different subset, and
+// requiring the unused ones forces callers to pad with "" — the guided
+// workflow's "pass ONLY this step's args" instruction then fails validation.
 const TOOL_ARGS = {
     // Step 1: Policy creation
-    name: z.string().describe("Policy name (for creating policy)"),
-    description: z.string().describe("Policy description (for creating policy)"),
-    orgUuid: z.string().describe("Organization UUID (for creating policy)"),
+    name: z.string().optional().describe("Policy name (for creating policy)"),
+    description: z.string().optional().describe("Policy description (for creating policy)"),
+    orgUuid: z.string().optional().describe("Organization UUID (for creating policy)"),
     // Step 2: Schedule configuration
-    policyUuid: z.string().describe("Policy UUID (for configuring schedules)"),
-    scheduleConfigs: z.string().describe("JSON string of schedule configurations"),
+    policyUuid: z
+        .string()
+        .optional()
+        .describe("Policy UUID of an EXISTING policy (for configuring schedules or assigning cameras on an already-created policy). Omit it when creating a policy — including on a single full call that also passes scheduleConfigs and cameraUuids."),
+    scheduleConfigs: z
+        .string()
+        .optional()
+        .describe(`JSON array string of schedule configurations: [{"scheduleUuid": <uuid>, "activities": [<activity>, ...]}]. ` +
+        `"activities" must be a real JSON array of activity strings, not a string containing an array, and each ` +
+        `value must be an API activity constant (e.g. ${SUGGESTED_CAMERA_ACTIVITIES.slice(0, 6).join(", ")}) — ` +
+        `never a display label like "Human Movement". Example: ${SCHEDULE_CONFIGS_EXAMPLE}`),
     // Step 3: Camera assignment
-    cameraUuids: z.string().describe("Comma-separated camera UUIDs to assign policy to"),
-    policyName: z.string().describe("Policy name (for reference)"),
+    cameraUuids: z
+        .string()
+        .optional()
+        .describe('Comma-separated camera UUIDs to assign policy to, e.g. "uuidA,uuidB". Camera uuids only — resolve names to uuids first.'),
+    policyName: z.string().optional().describe("Policy name (for reference)"),
 };
 const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+// Every result from this tool MUST carry structuredContent: the tool registers
+// an outputSchema, and the MCP SDK rejects any result without structuredContent
+// as "MCP error -32602" — which REPLACES the real failure text and historically
+// made the model (and user) see a validation crash instead of the API error.
+function errorResult(text) {
+    return {
+        isError: true,
+        content: [{ type: "text", text }],
+        structuredContent: { needUserInput: false, message: text },
+    };
+}
+// Errors are labelled by whether anything was written, because the caller cannot
+// otherwise tell. The guided workflow says "on error, STOP and make no further
+// calls" — correct after a partial mutation (a retry would create a SECOND
+// policy) and wrong before one, where a corrected retry is free. Prod 2026-08-04:
+// a malformed `scheduleConfigs` was rejected before any write, the model stopped
+// and apologized, and the identical request succeeded when the user asked again.
+const RETRYABLE_PREFIX = "RETRYABLE — nothing was created or changed by this call.";
+const PARTIAL_PREFIX = "PARTIAL STATE — do NOT retry this call and do NOT create another policy.";
+const RETRY_INSTRUCTION = "Fix the arguments named above, then call this tool ONCE more with corrected arguments. Do not tell the user the policy could not be created unless a corrected retry also fails.";
+function retryableError(detail) {
+    return errorResult(`${RETRYABLE_PREFIX} ${detail} ${RETRY_INSTRUCTION}`);
+}
+/** Retryable, but a policy from an earlier call already exists — don't re-create it. */
+function retryableStepError(detail, existingPolicyUuid) {
+    return errorResult(`${RETRYABLE_PREFIX} Policy ${existingPolicyUuid} already exists from an earlier call — do NOT create another one. ${detail} ${RETRY_INSTRUCTION}`);
+}
+function partialStateError(detail) {
+    return errorResult(`${PARTIAL_PREFIX} ${detail} Report exactly this state to the user.`);
+}
+// postApi returns {error: true, status: "..."} on transport/HTTP failures and
+// domain errors arrive as {error: true, errorMsg: "..."} — normalize both.
+function apiErrorText(result) {
+    return (result.errorMsg?.trim() ||
+        result.status?.trim() ||
+        "the Rhombus API reported a failure without a message");
+}
+/** api2 can succeed while reporting a caveat; dropping it hides real problems. */
+function apiWarningSuffix(result) {
+    const warning = result.warningMsg?.trim();
+    return warning ? ` Note from the API: ${warning}` : "";
+}
 const TOOL_HANDLER = async (args, extra) => {
     const { name, description, orgUuid, policyUuid, scheduleConfigs, cameraUuids, policyName } = args;
+    // An empty list is how the legacy step-1 call spells "no schedules yet", so it
+    // must not select the schedule phase. Detected by parsing, not by comparing to
+    // the literal "[]" — "[ ]" and "\"[]\"" used to slip past that compare and
+    // fall through into policy creation, silently creating a DUPLICATE policy.
+    const hasScheduleConfigs = Boolean(scheduleConfigs?.trim() && !isEmptyScheduleConfigs(scheduleConfigs));
+    const hasFullInputSet = Boolean(name?.trim() && hasScheduleConfigs && cameraUuids?.trim());
+    // A full input set PLUS a policyUuid is ambiguous: create everything, or treat
+    // the uuid as an existing policy? It used to silently fall through to
+    // camera-assignment-only and then report "setup completely finished" for a
+    // policy whose schedules were never configured.
+    if (hasFullInputSet && policyUuid?.trim()) {
+        return retryableError(`Ambiguous arguments: name, scheduleConfigs, and cameraUuids were all provided (a full creation call) together with policyUuid "${policyUuid.trim()}". ` +
+            `To create a new policy, drop policyUuid. To modify the existing policy ${policyUuid.trim()}, drop name and send policyUuid with ONE of scheduleConfigs or cameraUuids.`);
+    }
+    // Full run: all inputs present and no pre-existing policyUuid — create the
+    // policy, configure schedules, and assign cameras in ONE call. The guided
+    // workflow collects everything before confirming, and executing across three
+    // model round trips proved fragile: the model wobbles at each call boundary
+    // (re-renders forms, splits args wrong), so the boundaries are removed.
+    if (hasFullInputSet) {
+        // Validate BOTH structured inputs BEFORE any mutation, so anything wrong
+        // with them is a clean retryable failure rather than a half-built policy.
+        const parsedConfigs = parseScheduleConfigs(scheduleConfigs);
+        if (!parsedConfigs.ok) {
+            return retryableError(parsedConfigs.message);
+        }
+        const parsedCameras = parseCameraUuids(cameraUuids);
+        if (!parsedCameras.ok) {
+            return retryableError(parsedCameras.message);
+        }
+        const scheduledTriggers = parsedConfigs.value.map(config => ({
+            scheduleUuid: config.scheduleUuid,
+            triggerSet: config.activities.map(activity => ({ activity })),
+        }));
+        const cameraList = parsedCameras.value;
+        // Phase 1: create.
+        let createdUuid;
+        let createWarning = "";
+        try {
+            const payload = ApiPayloadSchema.parse({
+                policy: {
+                    name,
+                    description: description?.trim() ? description : undefined,
+                    orgUuid: orgUuid?.trim() ? orgUuid : undefined,
+                    scheduledTriggers: [],
+                },
+            });
+            const result = await createCameraPolicy(payload, extra._meta?.requestModifiers, extra.sessionId);
+            if (result.error) {
+                return retryableError(`Creating the policy failed: ${apiErrorText(result)}.`);
+            }
+            if (!result.policyUuid) {
+                return retryableError("Creating the policy returned no policyUuid, so it did not succeed.");
+            }
+            createdUuid = result.policyUuid;
+            createWarning = apiWarningSuffix(result);
+        }
+        catch (error) {
+            return retryableError(`Creating the policy failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
+        }
+        // Phase 2: schedules (updateCameraPolicy REPLACES the policy object, so
+        // resend the identity fields — see the legacy schedule branch below).
+        try {
+            const result = await postApi({
+                route: "/policy/updateCameraPolicy",
+                body: {
+                    policy: {
+                        uuid: createdUuid,
+                        name,
+                        description: description?.trim() ? description : undefined,
+                        scheduledTriggers,
+                    },
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result.error) {
+                return partialStateError(`Policy "${name}" was created (uuid ${createdUuid}) but configuring its schedules failed: ${apiErrorText(result)}. No cameras were assigned.`);
+            }
+            createWarning += apiWarningSuffix(result);
+        }
+        catch (error) {
+            return partialStateError(`Policy "${name}" was created (uuid ${createdUuid}) but configuring its schedules failed: ${error instanceof Error ? error.message : "Unknown error"}. No cameras were assigned.`);
+        }
+        // Phase 3: cameras.
+        try {
+            const result = await postApi({
+                route: "/camera/updateDetailsBulkV2",
+                body: {
+                    cameraBulkDetails: cameraList.map(cameraUuid => ({
+                        uuid: cameraUuid,
+                        policyUuid: createdUuid,
+                        policyUuidUpdated: true,
+                    })),
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result?.error) {
+                return partialStateError(`Policy "${name}" was created with its schedules (uuid ${createdUuid}) but camera assignment failed: ${apiErrorText(result)}.`);
+            }
+            createWarning += apiWarningSuffix(result);
+        }
+        catch (error) {
+            return partialStateError(`Policy "${name}" was created with its schedules (uuid ${createdUuid}) but camera assignment failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
+        }
+        const fullRunResponse = {
+            needUserInput: false,
+            message: `Policy "${name}" created with ${scheduledTriggers.length} schedule trigger(s) and assigned to ${cameraList.length} camera(s).${createWarning}`,
+            policyUuid: createdUuid,
+            policyName: name,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `🎉 Camera policy setup completely finished!\n\n✅ Policy "${name}" created with ${scheduledTriggers.length} schedule trigger(s)\n✅ Assigned to ${cameraList.length} camera(s)\n✅ Policy is now fully active${createWarning}`,
+                },
+            ],
+            structuredContent: fullRunResponse,
+        };
+    }
     // Step 3: Camera assignment (if cameraUuids provided)
     if (cameraUuids?.trim()) {
+        // Guard BEFORE the API call: an empty policyUuid here would write
+        // policyUuid: "" with policyUuidUpdated: true to every listed camera —
+        // i.e. UNASSIGN their existing policies, not assign the new one.
+        if (!policyUuid?.trim()) {
+            return retryableError(`Cannot assign cameras: policyUuid is empty, so the policy has not been created yet. ` +
+                `Either pass the full set (name, scheduleConfigs, cameraUuids) in one call to create everything at once, or create the policy first (name/description/orgUuid call) and pass the returned policyUuid.`);
+        }
+        const parsedCameras = parseCameraUuids(cameraUuids);
+        if (!parsedCameras.ok) {
+            // Previously an unusable cameraUuids string (e.g. ",") left this branch
+            // with no return at all and fell through into policy creation, creating a
+            // duplicate policy and reporting success.
+            return retryableStepError(parsedCameras.message, policyUuid.trim());
+        }
+        const cameraList = parsedCameras.value;
         try {
-            const cameraList = cameraUuids
-                .split(",")
-                .map((uuid) => uuid.trim())
-                .filter((uuid) => uuid);
-            if (cameraList.length > 0) {
-                const cameraPayload = {
+            const result = await postApi({
+                route: "/camera/updateDetailsBulkV2",
+                body: {
                     cameraBulkDetails: cameraList.map(cameraUuid => ({
                         uuid: cameraUuid,
                         policyUuid: policyUuid,
                         policyUuidUpdated: true,
                     })),
-                };
-                await postApi({
-                    route: "/camera/updateDetailsBulkV2",
-                    body: cameraPayload,
-                    modifiers: extra._meta?.requestModifiers,
-                    sessionId: extra.sessionId,
-                });
-                const jsonResultResponse = {
-                    needUserInput: false,
-                    message: `Excellent! Policy created and assigned to ${cameraList.length} camera(s)!`,
-                    policyUuid,
-                    policyName,
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `🎉 Camera policy setup completely finished!\n\n✅ Policy "${policyName}" assigned to ${cameraList.length} camera(s)\n✅ Policy is now fully active\n\nYour cameras will now generate alerts according to the policy configuration.`,
-                        },
-                    ],
-                    structuredContent: jsonResultResponse,
-                };
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result?.error) {
+                // Assigning cameras is idempotent, so a corrected retry is safe — but
+                // the policy itself already exists and must not be created again.
+                return retryableStepError(`Assigning the policy to the cameras failed: ${apiErrorText(result)}.`, policyUuid);
             }
-        }
-        catch (error) {
+            const warning = apiWarningSuffix(result);
+            const jsonResultResponse = {
+                needUserInput: false,
+                message: `Policy "${policyName?.trim() || policyUuid}" assigned to ${cameraList.length} camera(s).${warning}`,
+                policyUuid,
+                policyName,
+            };
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to assign policy to cameras: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        // Claims only what THIS call did: schedules may or may not have been
+                        // configured by an earlier call, and this branch cannot know.
+                        text: `✅ Policy "${policyName?.trim() || policyUuid}" assigned to ${cameraList.length} camera(s).${warning}`,
                     },
                 ],
+                structuredContent: jsonResultResponse,
             };
         }
+        catch (error) {
+            return retryableStepError(`Assigning the policy to the cameras failed: ${error instanceof Error ? error.message : "Unknown error"}.`, policyUuid);
+        }
     }
     // Step 2: Schedule configuration (if scheduleConfigs provided and non-empty)
-    if (scheduleConfigs?.trim() && scheduleConfigs.trim() !== "[]") {
+    if (hasScheduleConfigs) {
+        if (!policyUuid?.trim()) {
+            return retryableError(`Cannot configure schedules: policyUuid is empty. Create the policy first (name/description/orgUuid call) and pass the returned policyUuid, or pass the full set (name, scheduleConfigs, cameraUuids) in one call to do everything at once.`);
+        }
+        const parsedConfigs = parseScheduleConfigs(scheduleConfigs);
+        if (!parsedConfigs.ok) {
+            return retryableStepError(parsedConfigs.message, policyUuid.trim());
+        }
+        const scheduledTriggers = parsedConfigs.value.map(config => ({
+            scheduleUuid: config.scheduleUuid,
+            triggerSet: config.activities.map(activity => ({ activity })),
+        }));
+        // /policy/updateCameraPolicy has REPLACE semantics: any field omitted
+        // from the policy object is NULLED on the stored policy. Sending only
+        // {uuid, scheduledTriggers} erases the name/description that step 1
+        // just set (observed in ITG: wizard-created policies with name: null,
+        // invisible in the Console). Always resend the identity fields.
+        const effectiveName = policyName?.trim() || name?.trim();
+        if (!effectiveName) {
+            return retryableStepError(`Cannot configure schedules: policyName is required — updateCameraPolicy replaces the whole policy object, so omitting the name would erase it. Pass policyName (and description, if any) along with policyUuid and scheduleConfigs.`, policyUuid.trim());
+        }
         try {
-            const configs = JSON.parse(scheduleConfigs);
-            // Only proceed if we have actual schedule configurations
-            if (configs.length > 0) {
-                const scheduledTriggers = configs.map(config => ({
-                    scheduleUuid: config.scheduleUuid,
-                    triggerSet: config.activities.map(activity => ({ activity })),
-                }));
-                const payload = {
-                    policy: { uuid: policyUuid, scheduledTriggers },
-                };
-                const result = await postApi({
-                    route: "/policy/updateCameraPolicy",
-                    body: payload,
-                    modifiers: extra._meta?.requestModifiers,
-                    sessionId: extra.sessionId,
-                });
-                if (result.error) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to configure policy schedules: ${result.errorMsg || "Unknown error"}`,
-                            },
-                        ],
-                    };
-                }
-                // Success - now show camera assignment form
-                const jsonResultResponse = {
-                    needUserInput: true,
-                    message: `Excellent! Policy schedules configured.\n\nFinal step: Please select which cameras should use this policy.`,
-                    requestType: "camera-assignment",
-                    submitAction: "create-camera-policy-tool",
-                    policyUuid,
-                    policyName,
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(jsonResultResponse),
-                        },
-                    ],
-                    structuredContent: jsonResultResponse,
-                };
+            const result = await postApi({
+                route: "/policy/updateCameraPolicy",
+                body: {
+                    policy: {
+                        uuid: policyUuid,
+                        name: effectiveName,
+                        description: description?.trim() ? description : undefined,
+                        scheduledTriggers,
+                    },
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result.error) {
+                // Replacing the schedules is idempotent — safe to retry, as long as the
+                // policy is not created a second time.
+                return retryableStepError(`Configuring the policy schedules failed: ${apiErrorText(result)}.`, policyUuid);
             }
-            // If configs.length === 0, fall through to policy creation
-        }
-        catch (error) {
+            // Neutral, fact-only message: imperative text like "Please select
+            // which cameras..." is an instruction the model follows over the
+            // workflow playbook (observed: it re-rendered the confirm form or
+            // stopped mid-execution to ask for cameras it already had).
+            const jsonResultResponse = {
+                needUserInput: false,
+                message: `Schedules configured for policy "${effectiveName}" (${policyUuid}).${apiWarningSuffix(result)}`,
+                policyUuid,
+                policyName,
+            };
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Error configuring schedules: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        text: JSON.stringify(jsonResultResponse),
                     },
                 ],
+                structuredContent: jsonResultResponse,
             };
         }
+        catch (error) {
+            return retryableStepError(`Configuring the policy schedules failed: ${error instanceof Error ? error.message : "Unknown error"}.`, policyUuid);
+        }
     }
     // Step 1: Policy creation (if name provided)
     if (name?.trim()) {
@@ -150,22 +342,16 @@ const TOOL_HANDLER = async (args, extra) => {
             });
             const result = await createCameraPolicy(payload, extra._meta?.requestModifiers, extra.sessionId);
             if (result.error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Failed to create camera policy: ${result.errorMsg || "Unknown error"}`,
-                        },
-                    ],
-                };
+                return retryableError(`Creating the policy failed: ${apiErrorText(result)}.`);
+            }
+            if (!result.policyUuid) {
+                return retryableError("Creating the policy returned no policyUuid, so it did not succeed.");
             }
-            console.error(`[createCameraPolicyTool] -- Proceeding with schedule-trigger-configuration form. Got result ${JSON.stringify(result)}`);
-            // Success - now show schedule configuration form
+            console.error(`[createCameraPolicyTool] -- Policy created. Got result ${JSON.stringify(result)}`);
+            // Neutral, fact-only message (see the schedule-step comment above).
             const jsonResultResponse = {
-                needUserInput: true,
-                message: `Great! Your policy "${name}" was created with UUID: ${result.policyUuid}\n\nNext, let's configure when this policy should be active and what activities should trigger alerts.`,
-                requestType: "schedule-trigger-configuration",
-                submitAction: "create-camera-policy-tool",
+                needUserInput: false,
+                message: `Policy "${name}" created with UUID: ${result.policyUuid}${apiWarningSuffix(result)}`,
                 policyUuid: result.policyUuid,
                 policyName: name,
             };
@@ -180,29 +366,23 @@ const TOOL_HANDLER = async (args, extra) => {
             };
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error creating camera policy: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
+            return retryableError(`Creating the policy failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
         }
     }
-    // Step 0: Show initial form (no args provided)
+    // Step 0: no args provided — tell the caller what's needed (plain facts, no
+    // legacy elicitation requestType/submitAction hints).
+    const initialFormResponse = {
+        needUserInput: true,
+        message: "No policy was created — this call had no arguments. To create a camera policy, collect from the user: a policy name (required), an optional description, the schedule triggers, and the cameras to assign, then call this tool again with name, description, orgUuid, scheduleConfigs, and cameraUuids together.",
+    };
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({
-                    needUserInput: true,
-                    message: "Please provide the following information to create your camera policy:\n\n1. **Policy Name** (required): A descriptive name for the policy\n2. **Policy Description** (optional): What this policy does\n3. **Organization UUID** (optional): Leave blank to use your current organization\n\nOnce you provide this information, I'll create the policy for you.",
-                    requestType: "policy-creation-form",
-                    submitAction: "create-camera-policy-tool",
-                }),
+                text: JSON.stringify(initialFormResponse),
             },
         ],
+        structuredContent: initialFormResponse,
     };
 };
 export function createTool(server) {

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

@@ -3,40 +3,9 @@ import { CREATE_DOOR_SCHEDULE_EXCEPTION_INPUT_SCHEMA, DoorScheduleExceptionReque
 import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
 const TOOL_NAME = "door-schedule-exception-tool";
 const TOOL_DESCRIPTION = `
-This tool manages Rhombus door schedule exceptions. 
-A door lock/unlock exception is a one-time rule used to change an access controlled door's locked/unlocked state. 
-If a lock/unlock exception is enabled, it will overwrite the existing lock/unlock schedule. 
-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.
+Manages Rhombus door schedule exceptions — one-time overrides of an access-controlled door's lock/unlock schedule for specific dates/times; the regular schedule resumes once the exception passes. Use for requests like "unlock the front door this Saturday", "cancel/modify the holiday exception", "what schedule exceptions are set for <door/location>", including adding or removing doors on an existing exception.
 
-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.
-- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS}: Find door schedule exceptions across the organization, optionally filtered by date range.
-- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_LOCATION}: Find door schedule exceptions for a location. Requires locationUuid. Supports optional date range filters.
-- ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_DOOR}: Find door schedule exceptions for a door. Requires doorUuid. Supports optional date range filters.
-- ${DoorScheduleExceptionRequestType.GET_EXCEPTION}: Get a single door schedule exception by UUID. Requires exceptionUuid.
-- ${DoorScheduleExceptionRequestType.UPDATE_EXCEPTION}: Update a door schedule exception. Requires exception (DoorScheduleExceptionType object). If intervals are omitted but defaultState and date range are provided, the tool will generate a full-day interval.
-
-Use get-entity-tool to look up location and door UUIDs when needed.
-
----
-
-**Mutating doorUuids on an existing exception (add/remove/replace doors):**
-\`update-exception\` REPLACES \`doorUuids\` with whatever you pass — it is not a delta operation. To safely remove or add doors while preserving the others:
-
-1. Call \`find-exceptions\` (or \`get-exception\`) to fetch the exception. The response includes the **full \`doorUuids\` array** for that exception — that IS the current door list.
-2. Compute the new array yourself:
-   - **Remove doors:** filter the existing \`doorUuids\` array, dropping the ones to remove.
-   - **Add doors:** append the new UUIDs to the existing array (deduped).
-   - **Replace wholesale:** just use the new set.
-3. Call \`update-exception\` with \`exception.uuid\` and \`exception.doorUuids\` set to your computed array. Other fields (name, dates, intervals, defaultState) are optional — omit them to leave them unchanged.
-
-**You already have the current door list in the find-exceptions response.** Do not ask the user for it, do not claim you need additional lookups, and do not refuse the mutation citing missing context. The doorUuids array you got back IS the context.
+Modes via "requestType": ${DoorScheduleExceptionRequestType.CREATE_EXCEPTION}, ${DoorScheduleExceptionRequestType.UPDATE_EXCEPTION}, ${DoorScheduleExceptionRequestType.DELETE_EXCEPTION}, ${DoorScheduleExceptionRequestType.GET_EXCEPTION}, ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS}, ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_LOCATION}, ${DoorScheduleExceptionRequestType.FIND_EXCEPTIONS_FOR_DOOR} — per-mode requirements and the add/remove-doors procedure are documented on the parameters. Use get-entity-tool to resolve location and door UUIDs.
 `;
 function buildDateRangeFilter(args) {
     return {