rhombus-node-mcp 0.1.21 → 0.1.23

package/dist/filtering-utils.js

@@ -0,0 +1,298 @@
+import { z } from "zod";
+// ---------------------------------------------------------------------------
+// Shared tool arg schemas
+// ---------------------------------------------------------------------------
+export const INCLUDE_FIELDS_ARG = z
+    .array(z.string())
+    .nullable()
+    .describe(`Dot-notation field paths to include in the response (e.g. "vehicleEvents.vehicleLicensePlate").
+Pass null to return all fields. WARNING: some responses can exceed 400k characters — use includeFields
+to request only the data you need. For high-volume tools this may be required to get a complete answer.`);
+export const FILTER_BY_ARG = z
+    .array(z.object({
+    field: z
+        .string()
+        .describe("Dot-notation path within each array item to compare (e.g. 'vehicleLicensePlate', 'eventTimestamp')"),
+    op: z
+        .enum(["=", "!=", ">", ">=", "<", "<=", "contains"])
+        .describe("Comparison operator"),
+    value: z
+        .union([z.string(), z.number(), z.boolean()])
+        .describe("Value to compare against"),
+}))
+    .nullable()
+    .describe(`Filter array items in the response by field values. All conditions are ANDed.
+Example: [{field: "vehicleLicensePlate", op: "=", value: "ABC123"}, {field: "confidence", op: ">", value: 0.8}]
+Use alongside includeFields to get only the specific records and fields you need.`);
+/** These keys will always be included in processed output schemas */
+const INCLUDE_WHITELIST = ["requestType"];
+function buildTrie(paths) {
+    const trie = {};
+    for (const p of paths) {
+        const parts = p.split(".");
+        let node = trie;
+        for (const part of parts) {
+            if (!node[part])
+                node[part] = {};
+            node = node[part];
+        }
+    }
+    return trie;
+}
+function filterByTrie(obj, trie) {
+    // Empty trie at this level means "include everything"
+    if (Object.keys(trie).length === 0) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        const mapped = obj.map((item) => filterByTrie(item, trie)).filter((item) => item !== undefined);
+        return mapped.length > 0 ? mapped : undefined;
+    }
+    if (typeof obj === "object" && obj !== null) {
+        const result = {};
+        for (const key of Object.keys(trie)) {
+            if (key in obj) {
+                const child = filterByTrie(obj[key], trie[key]);
+                if (child !== undefined)
+                    result[key] = child;
+            }
+        }
+        return Object.keys(result).length > 0 ? result : undefined;
+    }
+    // Primitive reached with a non-empty trie — return as-is (e.g. the trie
+    // targeted a leaf that is a scalar)
+    return obj;
+}
+/**
+ * Filters an object to only include the specified dot-notation field paths.
+ *
+ * Examples:
+ *   filterIncludedFields(data, ["vehicleEvents.vehicleLicensePlate", "error"])
+ *   → keeps vehicleLicensePlate within each vehicleEvents item, and the top-level error field
+ */
+export function filterIncludedFields(obj, fieldsToInclude) {
+    if (!fieldsToInclude || fieldsToInclude.length === 0) {
+        return obj;
+    }
+    const trie = buildTrie(fieldsToInclude);
+    return filterByTrie(obj, trie);
+}
+// ---------------------------------------------------------------------------
+// applyFilterBy — predicate filtering of array items
+// ---------------------------------------------------------------------------
+function getNestedValue(obj, fieldPath) {
+    if (!fieldPath)
+        return obj;
+    const parts = fieldPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+function matchesCondition(item, condition) {
+    const actual = getNestedValue(item, condition.field);
+    const { op, value } = condition;
+    if (actual === undefined || actual === null)
+        return false;
+    switch (op) {
+        case "=":
+            // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for mixed string/number comparisons
+            return actual == value;
+        case "!=":
+            // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for mixed string/number comparisons
+            return actual != value;
+        case ">":
+            return Number(actual) > Number(value);
+        case ">=":
+            return Number(actual) >= Number(value);
+        case "<":
+            return Number(actual) < Number(value);
+        case "<=":
+            return Number(actual) <= Number(value);
+        case "contains":
+            return String(actual).toLowerCase().includes(String(value).toLowerCase());
+        default:
+            return false;
+    }
+}
+/**
+ * Filters array items in the output object based on field-level predicates.
+ * Conditions are grouped by their top-level key; arrays at that key are
+ * filtered so only items matching ALL conditions (AND) are kept.
+ *
+ * Example:
+ *   applyFilterBy({ vehicleEvents: [...] }, [
+ *     { field: "vehicleLicensePlate", op: "=", value: "ABC123" }
+ *   ])
+ *   → vehicleEvents array is filtered to items whose vehicleLicensePlate === "ABC123"
+ *
+ * Note: conditions whose `field` contains a dot are resolved by navigating the
+ * full path within each array item (e.g. "location.name" looks up item.location.name).
+ */
+export function applyFilterBy(obj, conditions) {
+    if (!conditions?.length || typeof obj !== "object" || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.filter((item) => conditions.every((c) => matchesCondition(item, c)));
+    }
+    // For object payloads, group conditions by the top-level key so we know
+    // which array in the payload each condition targets.
+    const conditionsByTopKey = {};
+    for (const cond of conditions) {
+        const dotIdx = cond.field.indexOf(".");
+        // If the field has no dot, it's a direct property of the array item —
+        // use the condition as-is against all array values in the object.
+        const topKey = dotIdx === -1 ? "*" : cond.field.substring(0, dotIdx);
+        const subField = dotIdx === -1 ? cond.field : cond.field.substring(dotIdx + 1);
+        if (!conditionsByTopKey[topKey])
+            conditionsByTopKey[topKey] = [];
+        conditionsByTopKey[topKey].push({ ...cond, field: subField });
+    }
+    const result = { ...obj };
+    for (const [topKey, keyConds] of Object.entries(conditionsByTopKey)) {
+        if (topKey === "*") {
+            // Apply conditions to every top-level array in the object
+            for (const k of Object.keys(result)) {
+                if (Array.isArray(result[k])) {
+                    result[k] = result[k].filter((item) => keyConds.every((c) => matchesCondition(item, c)));
+                }
+            }
+        }
+        else if (topKey in result && Array.isArray(result[topKey])) {
+            result[topKey] = result[topKey].filter((item) => keyConds.every((c) => matchesCondition(item, c)));
+        }
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// zodToDotNotationPaths — derive available field paths from an OUTPUT_SCHEMA
+// ---------------------------------------------------------------------------
+/**
+ * Recursively walks a Zod schema and returns all valid dot-notation field paths.
+ * Useful for auto-documenting available includeFields/filterBy paths in tool descriptions.
+ *
+ * Example: zodToDotNotationPaths(OUTPUT_SCHEMA)
+ *   → ["vehicleEvents", "vehicleEvents.uuid", "vehicleEvents.vehicleLicensePlate", "error", ...]
+ */
+export function zodToDotNotationPaths(schema, prefix = "") {
+    // Unwrap optional / nullable / default
+    if (schema instanceof z.ZodOptional ||
+        schema instanceof z.ZodNullable) {
+        return zodToDotNotationPaths(schema.unwrap(), prefix);
+    }
+    if (schema instanceof z.ZodDefault) {
+        return zodToDotNotationPaths(schema._def.innerType, prefix);
+    }
+    // Recurse into ZodObject shape
+    if (schema instanceof z.ZodObject) {
+        const paths = [];
+        for (const [key, value] of Object.entries(schema.shape)) {
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            paths.push(fullKey);
+            paths.push(...zodToDotNotationPaths(value, fullKey));
+        }
+        return paths;
+    }
+    // Recurse into ZodArray element
+    if (schema instanceof z.ZodArray) {
+        return zodToDotNotationPaths(schema.element, prefix);
+    }
+    // ZodUnion — collect from all branches (deduplicated by caller if needed)
+    if (schema instanceof z.ZodUnion) {
+        const paths = [];
+        for (const option of schema._def.options) {
+            paths.push(...zodToDotNotationPaths(option, prefix));
+        }
+        return paths;
+    }
+    // Scalar — no further nesting
+    return [];
+}
+// ---------------------------------------------------------------------------
+// createFilteringProxy — MCP server proxy that adds includeFields + filterBy
+// ---------------------------------------------------------------------------
+const FILTERING_DESCRIPTION_SUFFIX = `
+
+**Output filtering (all tools):**
+- \`includeFields\` (string[]): Dot-notation paths to keep in the response (e.g. \`"vehicleEvents.vehicleLicensePlate"\`). Omit to return all fields.
+- \`filterBy\` (array): Predicates to filter array items. Each entry: \`{field, op, value}\` where op is one of \`= != > >= < <= contains\`. All conditions are ANDed. Example: \`[{field:"vehicleLicensePlate", op:"=", value:"ABC123"}]\`
+WARNING: some tool responses exceed 400k characters — use these params to request only the data you need.`;
+function applyFilteringToResult(result, includeFields, filterBy) {
+    if (!includeFields?.length && !filterBy?.length)
+        return result;
+    // Always include whitelisted fields
+    const effectiveIncludeFields = includeFields?.length
+        ? [...INCLUDE_WHITELIST, ...includeFields]
+        : includeFields;
+    const filteredContent = result.content.map((item) => {
+        if (item.type !== "text")
+            return item;
+        try {
+            // biome-ignore lint/suspicious/noExplicitAny: runtime JSON manipulation
+            let parsed = JSON.parse(item.text);
+            if (filterBy?.length)
+                parsed = applyFilterBy(parsed, filterBy) ?? parsed;
+            if (effectiveIncludeFields?.length)
+                parsed = filterIncludedFields(parsed, effectiveIncludeFields) ?? parsed;
+            return { ...item, text: JSON.stringify(parsed) };
+        }
+        catch {
+            return item;
+        }
+    });
+    // biome-ignore lint/suspicious/noExplicitAny: runtime JSON manipulation
+    let filteredStructured = result.structuredContent;
+    if (filteredStructured) {
+        if (filterBy?.length)
+            filteredStructured = applyFilterBy(filteredStructured, filterBy) ?? filteredStructured;
+        if (effectiveIncludeFields?.length)
+            filteredStructured = filterIncludedFields(filteredStructured, effectiveIncludeFields) ?? filteredStructured;
+    }
+    return { ...result, content: filteredContent, structuredContent: filteredStructured };
+}
+/**
+ * Returns a Proxy over an McpServer that intercepts every `registerTool` call to:
+ * 1. Inject `includeFields` and `filterBy` into the tool's inputSchema
+ * 2. Append a description suffix explaining the filtering params
+ * 3. Wrap the handler to apply filtering to the tool result
+ *
+ * Tools whose names appear in `blacklist` are registered without modification.
+ *
+ * This means no individual tool needs to know about filtering — it is handled
+ * transparently for all tools registered through this proxy.
+ */
+export function createFilteringProxy(server, blacklist = new Set()) {
+    return new Proxy(server, {
+        get(target, prop, receiver) {
+            if (prop !== "registerTool") {
+                return Reflect.get(target, prop, receiver);
+            }
+            // biome-ignore lint/suspicious/noExplicitAny: proxy intercept
+            return function (name, config, handler) {
+                if (blacklist.has(name)) {
+                    return target.registerTool(name, config, handler);
+                }
+                const augmentedConfig = {
+                    ...config,
+                    description: (config.description ?? "") + FILTERING_DESCRIPTION_SUFFIX,
+                    inputSchema: {
+                        ...config.inputSchema,
+                        includeFields: INCLUDE_FIELDS_ARG,
+                        filterBy: FILTER_BY_ARG,
+                    },
+                };
+                // biome-ignore lint/suspicious/noExplicitAny: proxy intercept
+                const wrappedHandler = async (args, extra) => {
+                    const { includeFields, filterBy, ...restArgs } = args;
+                    const result = await handler(restArgs, extra);
+                    return applyFilteringToResult(result, includeFields, filterBy);
+                };
+                return target.registerTool(name, augmentedConfig, wrappedHandler);
+            };
+        },
+    });
+}

package/dist/index.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import "dotenv/config";
 import { serverInit } from "./createServer.js";
 import { logger } from "./logger.js";
@@ -14,14 +13,6 @@ async function main() {
     }
     logger.info("🌐 Using server url", serverUrl);
     await serverInit();
-    const server = new McpServer({
-        name: "rhombus",
-        version: "1.0.0",
-        capabilities: {
-            resources: {},
-            tools: {},
-        },
-    });
     if (TRANSPORT_TYPE === "stdio") {
         await stdioTransport();
     }

package/dist/logger.js

@@ -18,10 +18,10 @@ const appenders = {
     // stderr for terminal visibility (always available)
     stderr: { type: "stderr" },
     // only send warn+ to stderr (never stdout)
-    stderrWarnPlus: {
+    stderrInfo: {
         type: "logLevelFilter",
         appender: "stderr",
-        level: "warn",
+        level: "info",
     },
 };
 // Only add file appender if we successfully created the directory
@@ -36,14 +36,15 @@ if (fileLoggingEnabled) {
         layout: { type: "basic" },
     };
 }
+const stderrAppender = process.env.DEBUG === "true" ? "stderr" : "stderrInfo";
 // Configure categories based on available appenders
 const categories = {
     default: {
-        appenders: fileLoggingEnabled ? ["mcpFile", "stderrWarnPlus"] : ["stderrWarnPlus"],
-        level: "info",
+        appenders: fileLoggingEnabled ? ["mcpFile", stderrAppender] : [stderrAppender],
+        level: "trace",
     },
     mcp: {
-        appenders: fileLoggingEnabled ? ["mcpFile", "stderrWarnPlus"] : ["stderrWarnPlus"],
+        appenders: fileLoggingEnabled ? ["mcpFile", stderrAppender] : [stderrAppender],
         level: "trace",
     },
 };

package/dist/network.js

@@ -9,7 +9,7 @@ export const STATIC_HEADERS = {
     accept: "application/json",
 };
 export const AUTH_HEADERS = {
-    "x-auth-apikey": RHOMBUS_API_KEY,
+    "x-auth-apikey": RHOMBUS_API_KEY ?? "",
     "x-auth-scheme": "api-token",
 };
 export const appendQueryParams = (url, params) => {
@@ -26,8 +26,7 @@ export const appendQueryParams = (url, params) => {
     const queryString = existingSearchParams.toString();
     return queryString ? `${baseUrl}?${queryString}` : baseUrl;
 };
-export async function postApi({ route, body, modifiers, sessionId, }) {
-    let url = BASE_URL + route;
+export function constructRequestHeaders(url, modifiers, sessionId) {
     // construct auth headers
     let authHeaders = {};
     if (!sessionId) {
@@ -41,7 +40,13 @@ export async function postApi({ route, body, modifiers, sessionId, }) {
             logger.error(`No auth found for sessionId: ${sessionId}`);
             throw new Error(`No auth found for sessionId: ${sessionId}`);
         }
-        if ("apiKey" in auth) {
+        if ("oauthToken" in auth) {
+            authHeaders = {
+                Authorization: `Bearer ${auth.oauthToken}`,
+                "x-auth-scheme": "api-oauth-token",
+            };
+        }
+        else if ("apiKey" in auth) {
             authHeaders = {
                 "x-auth-apikey": auth.apiKey,
                 "x-auth-scheme": "api-token",
@@ -60,6 +65,9 @@ export async function postApi({ route, body, modifiers, sessionId, }) {
                 "x-auth-scheme": "web2",
                 cookie: auth.cookie,
             };
+            if ("sessionAlias" in auth) {
+                url = appendQueryParams(url, { _rs: auth.sessionAlias });
+            }
         }
     }
     // merge headers
@@ -71,6 +79,12 @@ export async function postApi({ route, body, modifiers, sessionId, }) {
     if (modifiers?.query) {
         url = appendQueryParams(url, modifiers.query);
     }
+    return { url, requestHeaders };
+}
+export async function postApi({ route, body, modifiers, sessionId, }) {
+    let url = BASE_URL + route;
+    const { url: newUrl, requestHeaders } = constructRequestHeaders(BASE_URL + route, modifiers, sessionId);
+    url = newUrl;
     // stringify body if it's not already a string
     if (typeof body === "object") {
         body = JSON.stringify(body);

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

@@ -0,0 +1,97 @@
+import { unlockDoor, getAccessControlGroups, getCredentialsByUser, getLockdownPlans, activateLockdown, deactivateLockdown, getDoorScheduleExceptions, getAccessGrants, getRemoteUnlockUsers, } from "../api/access-control-tool-api.js";
+import { AccessControlRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/access-control-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "access-control-tool";
+const TOOL_DESCRIPTION = `
+This tool manages Rhombus access control operations including door unlocking, access groups, credentials, lockdown plans, door schedules, and access grants.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${AccessControlRequestType.UNLOCK_DOOR}: Remotely unlock an access controlled door. Requires doorUuid.
+- ${AccessControlRequestType.GET_GROUPS}: List all access control groups in the organization.
+- ${AccessControlRequestType.GET_CREDENTIALS_BY_USER}: List all access control credentials for a specific user. Requires userUuid.
+- ${AccessControlRequestType.GET_LOCKDOWN_PLANS}: List all lockdown plans in the organization.
+- ${AccessControlRequestType.ACTIVATE_LOCKDOWN}: Activate a lockdown plan at a location. Requires locationUuid and lockdownPlanUuid.
+- ${AccessControlRequestType.DEACTIVATE_LOCKDOWN}: Deactivate a lockdown plan at a location. Requires locationUuid and lockdownPlanUuid.
+- ${AccessControlRequestType.GET_DOOR_SCHEDULES}: Get door schedule exceptions for a location. Requires locationUuid.
+- ${AccessControlRequestType.GET_ACCESS_GRANTS}: List location access grants (physical badge/card access). Optionally accepts locationUuid to filter by location. Each grant includes userUuids (directly assigned users), groupUuids (assigned access control groups), and doorUuids (the doors this grant provides access to).
+- ${AccessControlRequestType.GET_REMOTE_UNLOCK_USERS}: Get all users who have permission to remotely unlock doors at a location. Requires locationUuid. Returns a list of doors with remote unlock enabled and the users who can unlock each door, based on their permission group roles. This is the correct tool for questions about remote unlock permissions.
+
+Use the get-entity-tool with entityType ACCESS_CONTROL_DOOR to get door UUIDs.
+Use the user-tool to look up user UUIDs and resolve them to names/emails.
+Use the location-tool to get location UUIDs.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case AccessControlRequestType.UNLOCK_DOOR: {
+                if (!args.doorUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "doorUuid is required for unlock-door." }));
+                }
+                const unlockResult = await unlockDoor(args.doorUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ unlockResult });
+            }
+            case AccessControlRequestType.GET_GROUPS: {
+                const accessControlGroups = await getAccessControlGroups(requestModifiers, sessionId);
+                return createToolStructuredContent({ accessControlGroups });
+            }
+            case AccessControlRequestType.GET_CREDENTIALS_BY_USER: {
+                if (!args.userUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "userUuid is required for get-credentials-by-user." }));
+                }
+                const credentials = await getCredentialsByUser(args.userUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ credentials });
+            }
+            case AccessControlRequestType.GET_LOCKDOWN_PLANS: {
+                const lockdownPlans = await getLockdownPlans(requestModifiers, sessionId);
+                return createToolStructuredContent({ lockdownPlans });
+            }
+            case AccessControlRequestType.ACTIVATE_LOCKDOWN: {
+                if (!args.locationUuid || !args.lockdownPlanUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "locationUuid and lockdownPlanUuid are required for activate-lockdown." }));
+                }
+                const lockdownResult = await activateLockdown(args.locationUuid, args.lockdownPlanUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ lockdownResult });
+            }
+            case AccessControlRequestType.DEACTIVATE_LOCKDOWN: {
+                if (!args.locationUuid || !args.lockdownPlanUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "locationUuid and lockdownPlanUuid are required for deactivate-lockdown." }));
+                }
+                const lockdownResult = await deactivateLockdown(args.locationUuid, args.lockdownPlanUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ lockdownResult });
+            }
+            case AccessControlRequestType.GET_DOOR_SCHEDULES: {
+                if (!args.locationUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "locationUuid is required for get-door-schedules." }));
+                }
+                const doorScheduleExceptions = await getDoorScheduleExceptions(args.locationUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ doorScheduleExceptions });
+            }
+            case AccessControlRequestType.GET_ACCESS_GRANTS: {
+                const accessGrants = await getAccessGrants(args.locationUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ accessGrants });
+            }
+            case AccessControlRequestType.GET_REMOTE_UNLOCK_USERS: {
+                if (!args.locationUuid) {
+                    return createToolTextContent(JSON.stringify({ error: "locationUuid is required for get-remote-unlock-users." }));
+                }
+                const remoteUnlockUsers = await getRemoteUnlockUsers(args.locationUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ remoteUnlockUsers });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({ error: error.message });
+        }
+        return createToolStructuredContent({ error: "Unknown error" });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

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

@@ -0,0 +1,50 @@
+import { getOrgAlarmStatus, getAlertMonitoringThreatCases, getLocationAlarmStatus, } from "../api/alarm-monitoring-tool-api.js";
+import { AlarmMonitoringRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/alarm-monitoring-tool-types.js";
+import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
+const TOOL_NAME = "alarm-monitoring-tool";
+const TOOL_DESCRIPTION = `
+This tool retrieves alarm monitoring status and threat case information across Rhombus locations.
+
+It has the following modes of operation, determined by the "requestType" parameter:
+- ${AlarmMonitoringRequestType.ORG_STATUS}: Get the armed/disarmed alarm monitoring status for ALL locations in the organization in a single call.
+- ${AlarmMonitoringRequestType.GET_THREAT_CASES}: Retrieve alarm monitoring threat cases (security incidents). Supports filtering by time range and max results.
+- ${AlarmMonitoringRequestType.LOCATION_STATUS}: Get detailed alarm monitoring status for a specific location. Requires locationUuid.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case AlarmMonitoringRequestType.ORG_STATUS: {
+                const locationStatuses = await getOrgAlarmStatus(requestModifiers, sessionId);
+                return createToolStructuredContent({ locationStatuses });
+            }
+            case AlarmMonitoringRequestType.GET_THREAT_CASES: {
+                const threatCases = await getAlertMonitoringThreatCases(args.startTimeMs ?? undefined, args.endTimeMs ?? undefined, args.maxResults ?? undefined, requestModifiers, sessionId);
+                return createToolStructuredContent({ threatCases });
+            }
+            case AlarmMonitoringRequestType.LOCATION_STATUS: {
+                if (!args.locationUuid) {
+                    return createToolStructuredContent({
+                        error: "locationUuid is required for location-status.",
+                    });
+                }
+                const locationDetail = await getLocationAlarmStatus(args.locationUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ locationDetail });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({ error: error.message });
+        }
+        return createToolStructuredContent({ error: "Unknown error" });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}