rhombus-node-mcp 0.1.55 → 0.1.57

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

@@ -1,4 +1,5 @@
-import { postApi } from "../network/network.js";
+import { apiWarning, postApi, throwIfApiError } from "../network/network.js";
+import { cachedPostApi } from "../network/org-reference-cache.js";
 const PERMISSION_RANK = {
     LIVEONLY: 0,
     READONLY: 1,
@@ -14,9 +15,7 @@ export async function unlockDoor(doorUuid, requestModifiers, sessionId) {
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return { success: true, doorUuid };
 }
 export async function getAccessControlGroups(requestModifiers, sessionId) {
@@ -26,9 +25,7 @@ export async function getAccessControlGroups(requestModifiers, sessionId) {
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return (res.groups?.map((group) => ({
         uuid: group.uuid ?? undefined,
         name: group.name ?? undefined,
@@ -44,9 +41,7 @@ export async function getCredentialsByUser(userUuid, requestModifiers, sessionId
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return (res.credentials?.map((cred) => ({
         uuid: cred.uuid ?? undefined,
         userUuid: cred.userUuid ?? undefined,
@@ -62,9 +57,7 @@ export async function getLockdownPlans(requestModifiers, sessionId) {
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return (res.lockdownPlans?.map((plan) => ({
         uuid: plan.uuid ?? undefined,
         name: plan.name ?? undefined,
@@ -80,9 +73,7 @@ export async function activateLockdown(locationUuid, lockdownPlanUuid, requestMo
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return { success: true, locationUuid, action: "activated" };
 }
 export async function deactivateLockdown(locationUuid, lockdownPlanUuid, requestModifiers, sessionId) {
@@ -92,9 +83,7 @@ export async function deactivateLockdown(locationUuid, lockdownPlanUuid, request
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return { success: true, locationUuid, action: "deactivated" };
 }
 export async function getDoorScheduleExceptions(locationUuid, requestModifiers, sessionId) {
@@ -104,9 +93,7 @@ export async function getDoorScheduleExceptions(locationUuid, requestModifiers,
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     return (res.exceptions?.map((exc) => ({
         uuid: exc.uuid ?? undefined,
         name: exc.name ?? undefined,
@@ -129,9 +116,7 @@ export async function getAccessGrants(locationUuid, requestModifiers, sessionId)
             modifiers: requestModifiers,
             sessionId,
         });
-    if (res.error) {
-        throw new Error(JSON.stringify(res));
-    }
+    throwIfApiError(res);
     const filterNulls = (arr) => arr?.filter((v) => v !== null) ?? [];
     return (res.accessGrants?.map((grant) => ({
         uuid: grant.uuid ?? undefined,
@@ -177,7 +162,7 @@ export async function getRemoteUnlockUsers(locationUuid, requestModifiers, sessi
             modifiers: requestModifiers,
             sessionId,
         }),
-        postApi({
+        cachedPostApi({
             route: "/component/findAccessControlledDoors",
             body: {},
             modifiers: requestModifiers,
@@ -190,12 +175,9 @@ export async function getRemoteUnlockUsers(locationUuid, requestModifiers, sessi
             sessionId,
         }),
     ]);
-    if (permGroupsRes.error)
-        throw new Error(JSON.stringify(permGroupsRes));
-    if (doorsRes.error)
-        throw new Error(JSON.stringify(doorsRes));
-    if (usersRes.error)
-        throw new Error(JSON.stringify(usersRes));
+    throwIfApiError(permGroupsRes);
+    throwIfApiError(doorsRes);
+    throwIfApiError(usersRes);
     const permissionGroups = permGroupsRes.permissionGroups ?? [];
     const groupMembership = {};
     for (const [groupUuid, userUuids] of Object.entries(permGroupsRes.groupMembership ?? {})) {
@@ -254,3 +236,220 @@ export async function getRemoteUnlockUsers(locationUuid, requestModifiers, sessi
     const totalUsers = seenUsers.size;
     return { doors: doorNames, totalUsers, groups };
 }
+// ---------------------------------------------------------------------------
+// Access control groups
+// ---------------------------------------------------------------------------
+export async function createAccessControlGroup(name, description, userUuids, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/createAccessControlGroup",
+        body: {
+            name,
+            description: description || undefined,
+            userUuids: userUuids ?? [],
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        success: true,
+        uuid: res.group?.uuid ?? undefined,
+        memberCount: res.groupMembers?.length ?? userUuids?.length ?? 0,
+    };
+}
+export async function updateAccessControlGroup(groupUuid, changes, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/updateAccessControlGroup",
+        body: {
+            groupUuid,
+            name: changes.name,
+            description: changes.description,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: groupUuid };
+}
+export async function deleteAccessControlGroup(groupUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/deleteAccessControlGroup",
+        body: { groupUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: groupUuid };
+}
+export async function changeAccessControlGroupMembers(groupUuid, userUuids, action, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: action === "add"
+            ? "/accesscontrol/addUsersToAccessControlGroup"
+            : "/accesscontrol/removeUsersFromAccessControlGroup",
+        body: { groupUuid, userUuids },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: groupUuid, userCount: userUuids.length };
+}
+// ---------------------------------------------------------------------------
+// Location access grants
+// ---------------------------------------------------------------------------
+/**
+ * `createAccessGrant` / `updateAccessGrant` both take the WHOLE grant object,
+ * so update callers must read the current grant and merge. Both can also
+ * succeed while reporting doors whose access-control licences are expired or
+ * unassigned — those doors silently do not get access, so they are surfaced.
+ */
+export async function writeAccessGrant(accessGrant, mode, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: mode === "create"
+            ? "/accesscontrol/createAccessGrant"
+            : "/accesscontrol/updateAccessGrant",
+        body: {
+            accessGrant,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        success: true,
+        uuid: res.accessGrant?.uuid ?? accessGrant.uuid,
+        expiredACDLicensesDoorUuids: res.expiredACDLicensesDoorUuids?.filter((value) => !!value) ?? [],
+        unassignedACDLicensesDoorUuids: res.unassignedACDLicensesDoorUuids?.filter((value) => !!value) ?? [],
+        warningMsg: res.warningMsg ?? undefined,
+    };
+}
+export async function deleteAccessGrant(accessGrantUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/deleteLocationAccessGrant",
+        body: {
+            accessGrantUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: accessGrantUuid, warningMsg: res.warningMsg ?? undefined };
+}
+// ---------------------------------------------------------------------------
+// Credentials
+// ---------------------------------------------------------------------------
+/** Attach an existing (unassigned) physical credential to a user. */
+export async function assignCredential(credentialHexValue, userUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/assignAccessControlCredential",
+        body: {
+            credentialHexValue,
+            userUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, userUuid, warningMsg: apiWarning(res) };
+}
+/**
+ * The four credential state changes that share a `{credentialUuid}` body.
+ *
+ * They are NOT interchangeable and the difference matters operationally:
+ * suspend is reversible (unsuspend restores it), revoke detaches the credential
+ * from its user but keeps the record, and delete destroys the record entirely.
+ */
+export async function changeCredentialState(credentialUuid, action, requestModifiers, sessionId) {
+    const routes = {
+        revoke: "/accesscontrol/revokeAccessControlCredential",
+        suspend: "/accesscontrol/suspendAccessControlCredential",
+        unsuspend: "/accesscontrol/unsuspendAccessControlCredential",
+        delete: "/accesscontrol/deleteAccessControlCredential",
+    };
+    const res = await postApi({
+        route: routes[action],
+        body: {
+            credentialUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: credentialUuid, warningMsg: apiWarning(res) };
+}
+export async function updateCredentialNote(credentialUuid, note, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/updateAccessControlCredentialNote",
+        body: {
+            credentialUuid,
+            note,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: credentialUuid, warningMsg: apiWarning(res) };
+}
+// ---------------------------------------------------------------------------
+// Lockdown plans
+// ---------------------------------------------------------------------------
+export async function getLockdownPlan(lockdownPlanUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/getLockdownPlan",
+        body: {
+            lockdownPlanUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return res.lockdownPlan ?? undefined;
+}
+/**
+ * Rename a lockdown plan.
+ *
+ * `updateLocationLockdownPlan` takes the plan's door-state map, activation,
+ * deactivation and test plans as sibling fields, so a name-only body would blank
+ * them — which on a lockdown plan means doors silently stop locking in an
+ * emergency. Everything except the name is therefore read back and resent
+ * verbatim. Authoring those nested plans from natural language is deliberately
+ * NOT exposed.
+ */
+export async function renameLockdownPlan(lockdownPlanUuid, name, requestModifiers, sessionId) {
+    const existing = await getLockdownPlan(lockdownPlanUuid, requestModifiers, sessionId);
+    if (!existing)
+        return { success: false, missing: true };
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/updateLocationLockdownPlan",
+        body: {
+            lockdownPlanUuid,
+            name,
+            activationPlan: existing.activationPlan,
+            deactivationPlan: existing.deactivationPlan,
+            defaultLockdownState: existing.defaultLockdownState,
+            doorLockdownStateMap: existing.doorLockdownStateMap,
+            physicalAccess: existing.physicalAccess,
+            testPlan: existing.testPlan,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        success: true,
+        missing: false,
+        uuid: lockdownPlanUuid,
+        previousName: existing.name ?? undefined,
+    };
+}
+export async function deleteLockdownPlan(lockdownPlanUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/accesscontrol/lockdownPlan/deleteLockdownPlan",
+        body: {
+            lockdownPlanUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: lockdownPlanUuid };
+}

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

@@ -1,4 +1,4 @@
-import { postApi } from "../network/network.js";
+import { apiWarning, postApi, throwIfApiError } from "../network/network.js";
 export async function getOrgAlarmStatus(requestModifiers, sessionId) {
     const res = await postApi({
         route: "/alertmonitoring/orgStatus",
@@ -63,3 +63,52 @@ export async function getLocationAlarmStatus(locationUuid, requestModifiers, ses
         notEnabledReason: res.status?.notEnabledReason ?? undefined,
     };
 }
+// ---------------------------------------------------------------------------
+// Alarm monitoring write paths
+//
+// `armMonitoring` / `disarmMonitoring` are deliberately NOT exposed: their
+// `armingRule` / `disarmingRule` bodies (activeSinceMs, armAllUntilMs,
+// armedAlarmPolicies) have semantics that are not documented in the api2 spec,
+// and getting them wrong leaves a real alarm system in a state nobody asked
+// for. enable/disable below are the unambiguous pair, and they require the
+// location's alarm PIN.
+// ---------------------------------------------------------------------------
+/**
+ * Turn alarm monitoring on or off for a location.
+ *
+ * `pin` is the location's alarm PIN, supplied by the user. It is passed straight
+ * through to api2 and must never be echoed into a tool result, a note, or a log
+ * line.
+ */
+export async function setLocationMonitoring(locationUuid, pin, enabled, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: enabled
+            ? "/alertmonitoring/enableMonitoringForLocation"
+            : "/alertmonitoring/disableMonitoringForLocation",
+        body: {
+            locationUuid,
+            pin,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, locationUuid, enabled, warningMsg: res.warningMsg ?? undefined };
+}
+export async function changeThreatCaseState(threatCaseUuid, action, requestModifiers, sessionId) {
+    const routes = {
+        dismiss: "/alertmonitoring/dismissThreatCase",
+        cancel: "/alertmonitoring/cancelThreatCase",
+        escalate: "/alertmonitoring/escalateThreatCaseToAlarm",
+    };
+    const res = await postApi({
+        route: routes[action],
+        body: {
+            uuid: threatCaseUuid,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return { success: true, uuid: threatCaseUuid, action, warningMsg: apiWarning(res) };
+}

package/dist/api/automated-prompts-tool-api.js

@@ -1,4 +1,4 @@
-import { postApi } from "../network/network.js";
+import { postApi, throwIfApiError } from "../network/network.js";
 import { ChatFollowUpActionEnum, } from "../types/automated-prompts-tool-types.js";
 import { formatIsoWithOffset } from "../util.js";
 function extractNotifyUserUuids(followUpActions) {
@@ -88,8 +88,7 @@ export async function listAutomatedPrompts(pageRequest, requestModifiers, sessio
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     const settingsList = (res.settingsList ?? [])
         .map((p) => toSummary(p, timeZone))
         .filter((s) => s !== undefined);
@@ -105,8 +104,7 @@ export async function getAutomatedPrompt(promptUuid, requestModifiers, sessionId
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return toSummary(res.settings, timeZone);
 }
 export async function createAutomatedPrompt(input, requestModifiers, sessionId, timeZone) {
@@ -117,8 +115,7 @@ export async function createAutomatedPrompt(input, requestModifiers, sessionId,
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return toSummary(res.settings, timeZone);
 }
 export async function updateAutomatedPrompt(input, requestModifiers, sessionId, timeZone) {
@@ -129,8 +126,7 @@ export async function updateAutomatedPrompt(input, requestModifiers, sessionId,
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return toSummary(res.settings, timeZone);
 }
 export async function deleteAutomatedPrompt(promptUuid, requestModifiers, sessionId) {
@@ -140,8 +136,7 @@ export async function deleteAutomatedPrompt(promptUuid, requestModifiers, sessio
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return { ok: true, action: "deleted" };
 }
 export async function getAutomatedPromptChatHistory(promptUuid, pageRequest, requestModifiers, sessionId, timeZone) {
@@ -155,8 +150,7 @@ export async function getAutomatedPromptChatHistory(promptUuid, pageRequest, req
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     const chatHistory = (res.chatHistory ?? [])
         .map((r) => toHistoryEntry(r, timeZone))
         .filter((e) => e !== undefined);
@@ -175,8 +169,7 @@ export async function shareAutomatedPromptResponse(chatUuid, visibility, request
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return { ok: true, action: `visibility set to ${visibility}` };
 }
 export async function verifyJobScheduled(promptUuid, requestModifiers, sessionId) {
@@ -186,8 +179,7 @@ export async function verifyJobScheduled(promptUuid, requestModifiers, sessionId
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return {
         scheduleExpression: res.scheduleExpression ?? undefined,
         scheduleTimezone: res.scheduleTimezone ?? undefined,

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

@@ -0,0 +1,122 @@
+import { postApi, throwIfApiError } from "../network/network.js";
+import { describeWeeklyInterval } from "../util.js";
+function mapPolicy(raw) {
+    return {
+        uuid: raw.uuid ?? undefined,
+        name: raw.name ?? undefined,
+        description: raw.description ?? undefined,
+        defaultActivities: raw.defaultTriggers?.flatMap(trigger => trigger?.activity ? [trigger.activity] : []) ?? [],
+        scheduledTriggers: raw.scheduledTriggers?.flatMap(trigger => {
+            if (!trigger)
+                return [];
+            return [
+                {
+                    scheduleUuid: trigger.schedule?.uuid ?? undefined,
+                    scheduleName: trigger.schedule?.name ?? undefined,
+                    scheduleWindows: trigger.schedule?.intervalList?.flatMap(interval => {
+                        const window = describeWeeklyInterval(interval?.minuteOfWeekStart, interval?.minuteOfWeekStop);
+                        return window ? [window] : [];
+                    }) ?? [],
+                    activities: trigger.triggerSet?.flatMap(entry => entry?.activity ? [entry.activity] : []) ?? [],
+                },
+            ];
+        }) ?? [],
+    };
+}
+export async function getCameraPolicies(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/policy/getCameraPolicies",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        policies: res.policies?.flatMap(raw => (raw ? [mapPolicy(raw)] : [])) ?? [],
+        warningMsg: res.warningMsg ?? undefined,
+    };
+}
+/**
+ * api2's `updateCameraPolicy` REPLACES the whole policy object, so any field the
+ * caller leaves out is blanked. Callers must read the current policy and merge
+ * before calling this — see the tool's update branch.
+ */
+export async function updateCameraPolicy(policy, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/policy/updateCameraPolicy",
+        body: { policy },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        updated: { success: true, policyUuid: policy.uuid },
+        warningMsg: res.warningMsg ?? undefined,
+    };
+}
+export async function deleteCameraPolicy(policyUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/policy/deleteCameraPolicy",
+        body: { policyUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        deleted: { success: true, policyUuid },
+        warningMsg: res.warningMsg ?? undefined,
+    };
+}
+/**
+ * The camera holds its `policyUuid`, not the policy a camera list — so "which
+ * cameras does this policy cover" is only answerable by listing cameras and
+ * grouping. Callers use this both to enrich reads and to warn before a delete.
+ */
+export async function getCamerasByPolicy(requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/getMinimalCameraStateList",
+        body: {},
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    const byPolicy = new Map();
+    for (const camera of res.cameraStates ?? []) {
+        if (!camera?.policyUuid)
+            continue;
+        const bucket = byPolicy.get(camera.policyUuid) ?? [];
+        bucket.push({ uuid: camera.uuid ?? undefined, name: camera.name ?? undefined });
+        byPolicy.set(camera.policyUuid, bucket);
+    }
+    return byPolicy;
+}
+/**
+ * Assign or clear the policy on a set of cameras. Passing a null `policyUuid`
+ * with `policyUuidUpdated: true` is how api2 spells "unassign", so the caller
+ * must be explicit about which one it means.
+ *
+ * It must be `null` and not `""`: `policyUuid` is declared
+ * `format: RUUID, nullable: true`, so an empty string fails deserialization and
+ * api2 rejects the whole bulk body with
+ * `HTTP 400 {"msg":"JSON doesn't match expected object structure"}`.
+ * Verified against api2.itg on 2026-08-05 — a mocked test cannot catch this.
+ */
+export async function setPolicyOnCameras(cameraUuids, policyUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/camera/updateDetailsBulkV2",
+        body: {
+            cameraBulkDetails: cameraUuids.map(uuid => ({
+                uuid,
+                policyUuid,
+                policyUuidUpdated: true,
+            })),
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    throwIfApiError(res);
+    return {
+        cameraCount: cameraUuids.length,
+        warningMsg: res.warningMsg ?? undefined,
+    };
+}

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

@@ -1,5 +1,5 @@
 import { getLogger } from "../logger.js";
-import { postApi } from "../network/network.js";
+import { postApi, throwIfApiError } from "../network/network.js";
 import { removeNullFields } from "../util.js";
 const logger = getLogger("camera-tool");
 const MILLISECONDS_PER_DAY = 24 * 60 * 60 * 1000;
@@ -142,8 +142,7 @@ export async function getCameraMediaUris(cameraUuid, requestModifiers, sessionId
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return res;
 }
 export async function getCameraAIThresholds(cameraUuid, requestModifiers, sessionId) {
@@ -153,8 +152,7 @@ export async function getCameraAIThresholds(cameraUuid, requestModifiers, sessio
         modifiers: requestModifiers,
         sessionId,
     });
-    if (res.error)
-        throw new Error(JSON.stringify(res));
+    throwIfApiError(res);
     return res;
 }
 export async function updateCameraSettings(cameraUuid, update, requestModifiers, sessionId) {