rhombus-node-mcp 0.1.15 → 0.1.16

package/dist/tools/create-tool.js

@@ -1,79 +1,30 @@
-import { z } from "zod";
-import { logger } from "../logger.js";
-import { postApi } from "../network.js";
-import { CreateVideoWallOptions } from "../types.js";
-import { addConfirmationParams, requireConfirmation } from "../utils/confirmation.js";
-async function createVideoWall(options, requestModifiers) {
-    const body = {
-        videoWall: {
-            displayName: options?.displayName,
-            deviceList: options?.deviceList,
-            othersCanEdit: true,
-            orgUuid: options?.orgUuid,
-            shared: true,
-            settings: {
-                gridSize: { width: options?.settings.columnCount, height: options?.settings.columnCount },
-                gridLayout: "1 2\n3 4",
-                intervalSeconds: options?.settings.intervalSeconds || 5,
-            },
-        },
-    };
-    const response = await postApi("/camera/createVideoWall", body, requestModifiers);
-    return response;
-}
-async function handleCreateVideoWallRequest(videoWallCreateOptions, requestModifiers) {
-    let text = "Unable to create video wall!";
-    logger.info("🔨 Creating video wall");
-    if (!videoWallCreateOptions?.displayName) {
-        text = JSON.stringify({
-            needUserInput: true,
-            commandForUser: "What should the name of the video wall be?",
-        });
-    }
-    else if ((videoWallCreateOptions?.deviceList || []).length === 0) {
-        text = JSON.stringify({
-            needUserInput: true,
-            commandForUser: "Which cameras would you like on this video wall?",
-        });
+import { requireConfirmation } from "../utils/confirmation.js";
+import { handleCreateVideoWallRequest } from "../api/create-tool-api.js";
+import { TOOL_ARGS } from "../types/create-tool-types.js";
+const TOOL_NAME = "create-tool";
+const TOOL_DESCRIPTION = "Tool for creating many entity types such as video walls.";
+const TOOL_HANDLER = async (args, extra) => {
+    const { entityType, videoWallCreateOptions, confirmationId } = args;
+    const confirmation = requireConfirmation(confirmationId);
+    if (confirmation === true) {
+        switch (entityType) {
+            case "video-wall":
+                return await handleCreateVideoWallRequest(videoWallCreateOptions, extra._meta?.requestModifiers, extra.sessionId);
+            default:
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "",
+                },
+            ],
+        };
     }
     else {
-        logger.info("Creating video wall with options: ", JSON.stringify(videoWallCreateOptions));
-        text = JSON.stringify(await createVideoWall(videoWallCreateOptions, requestModifiers));
+        return confirmation;
     }
-    return Promise.resolve({
-        content: [
-            {
-                type: "text",
-                text,
-            },
-        ],
-    });
-}
+};
 export function createTool(server) {
-    server.tool("create-tool", "Tool for creating many entity types such as video walls.", addConfirmationParams({
-        entityType: z
-            .enum(["video-wall"])
-            .describe("The entity type to create.  Example: video wall."),
-        videoWallCreateOptions: CreateVideoWallOptions,
-    }), async ({ entityType, videoWallCreateOptions, confirmationId }, extra) => {
-        const confirmation = requireConfirmation(confirmationId);
-        if (confirmation === true) {
-            switch (entityType) {
-                case "video-wall":
-                    return await handleCreateVideoWallRequest(videoWallCreateOptions, extra._meta?.requestModifiers);
-                default:
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: "",
-                    },
-                ],
-            };
-        }
-        else {
-            return confirmation;
-        }
-    });
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
 }

package/dist/tools/entity-lookup-tool.js

@@ -0,0 +1,35 @@
+import { getAllEntities } from "../api/entity-lookup-tool-api.js";
+import { OUTPUT_SCHEMA, TOOL_ARGS } from "../types/entity-lookup-tool-types.js";
+import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
+const TOOL_NAME = "entity-lookup-tool";
+const TOOL_DESCRIPTION = `
+Retrieves specific entities (or devices) by their UUIDs.
+Takes a list of device UUIDs and returns the device information for those specific devices.
+The return structure is a JSON object that contains the states of the requested entities.
+This data is exact. Only devices with matching UUIDs will be returned.
+`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { deviceUuids, timeZone, tempUnit } = args;
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
+    try {
+        const result = await getAllEntities(deviceUuids, timeZone, tempUnit, requestModifiers, sessionId);
+        return createToolStructuredContent(result);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({
+                error: error.message,
+            });
+        }
+        return createToolStructuredContent({
+            error: "Unknown error",
+        });
+    }
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

package/dist/tools/events-tool.js

@@ -1,100 +1,196 @@
-import { z } from "zod";
-import { FIVE_SECONDS_MS, THREE_HOURS_MS } from "../constants.js";
-import { postApi } from "../network.js";
-async function getFaceEvents(_locationUuid, requestModifiers) {
-    const nowMs = Date.now();
-    const rangeStartMs = nowMs - THREE_HOURS_MS;
-    const rangeEndMs = nowMs - FIVE_SECONDS_MS;
-    const body = {
-        pageRequest: {
-            lastEvaluatedKey: undefined,
-            maxPageSize: 75,
-        },
-        searchFilter: {
-            deviceUuids: [],
-            faceNames: [],
-            labels: [],
-            locationUuids: [],
-            personUuids: [],
-            timestampFilter: {
-                rangeStart: rangeStartMs,
-                rangeEnd: rangeEndMs,
-            },
-        },
-    };
-    const response = await postApi("/faceRecognition/faceEvent/findFaceEventsByOrg", body, requestModifiers).then(response => {
-        return {
-            faceEvents: (response.faceEvents || []).map((event) => ({
-                ...event,
-                eventTimestamp: new Date(event.eventTimestamp).toString(),
-            })),
-        };
-    });
-    return response;
-}
-async function getAccessControlEvents(doorUuid, requestModifiers) {
-    const body = {
-        limit: 50,
-        accessControlledDoorUuid: doorUuid,
-    };
-    const response = await postApi("/component/findComponentEventsByAccessControlledDoor", body, requestModifiers).then(response => ({
-        componentEvents: (response.componentEvents || []).map((event) => ({
-            ...event,
-            timestamp: new Date(event.timestampMs).toString(),
-        })),
-    }));
-    return response;
-}
-export function createTool(server) {
-    server.tool("events-tool", "event data for certain types of information like faces, license plates, and access-control events", {
-        eventType: z.enum(["faces", "people", "access-control"]),
-        locationUuid: z.optional(z.string()),
-        accessControlledDoorUuid: z.optional(z.string()),
-    }, async ({ eventType, locationUuid, accessControlledDoorUuid }, extra) => {
-        if (eventType === "faces" || eventType === "people") {
-            const response = await getFaceEvents(locationUuid, extra._meta?.requestModifiers);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(response),
-                    },
-                ],
-            };
+import { getAccessControlEvents, getEventsForEnvironmentalGateway, getClimateEventsForSensor, getComponentEventsByLocation, getHumanMotionEvents, } from "../api/events-tool-api.js";
+import { EventsToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/events-tools-types.js";
+import { createToolStructuredContent } from "../util.js";
+import { getLogger } from "../logger.js";
+import { TempUnit } from "../utils/temp.js";
+const logger = getLogger("events-tool");
+const TOOL_NAME = "events-tool";
+// "faces" | "people" | "human" | "access-control"
+const TOOL_DESCRIPTION = `
+This tool interacts with the Rhombus events system to retrieve information about various types of events within the system. It has 5 modes of operation, determined by the "eventType" parameter: access-control, environmental-gateway, climate-sensor, component-events, and camera
+
+This tool should should be used any time someone is asking for specifics or reports for access control related events like unlocks, badge ins, credentials, arrivals etc., environmental gateway events, climate sensor events, camera motion events, or any other component events.
+
+For maximum flexibility, use eventType "component-events" which allows querying any combination of event types (doorbell pushes, badge scans, door state changes, button presses, etc.) for a location.
+
+This tool retrieves a list of events captured by the access control door system pertaining to arrivals, badge ins, credentials received, etc. 
+
+This tool can return a lot of data. Please make sure the time range provided is not too large.
+  This tool takes 3 arguments:
+  * **accessControlledDoorUuid (string):** The unique identifier for the access controlled door.
+  * **startTime (string):** The timestamp (in ISO 8601 format) representing the start or earliest time of access control events.
+  * **endTime (string):** The timestamp (in ISO 8601 format) representing the end or latest time of access control events.
+
+  The tool returns a JSON object with access control events data.
+
+When eventType is "environmental-gateway":
+
+This tool retrieves environmental gateway events for a specific environmental gateway device within a time range. The data returned will have a timestamp that is in
+the timezone of the **device**, not necessarily UTC time.
+
+This tool takes 3 arguments:
+  * **deviceUuid (string):** The unique identifier for the environmental gateway device.
+  * **startTime (string):** The timestamp (in ISO 8601 format) representing the start time of events.
+  * **endTime (string):** The timestamp (in ISO 8601 format) representing the end time of events.
+
+The tool returns a JSON object with environmental gateway events data.
+
+When eventType is "climate-sensor":
+
+This tool retrieves climate sensor events for a specific climate sensor within a time range. The data returned will have a timestamp that is in
+the timezone of the **sensor**, not necessarily UTC time.
+
+This tool takes 4 arguments:
+  * **sensorUuid (string):** The unique identifier for the climate sensor.
+  * **startTime (string):** The timestamp (in ISO 8601 format) representing the start time of events.
+  * **endTime (string):** The timestamp (in ISO 8601 format) representing the end time of events.
+  * **limit (number, optional):** Maximum number of climate events to return. Default is 1000.
+
+The tool returns a JSON object with climate sensor events data.
+
+When eventType is "component-events":
+
+This tool retrieves ALL types of component events for a specific location within a time range. This is the most flexible option and allows filtering by specific event types. The data returned will have a timestamp that is in the timezone of the **location**, not necessarily UTC time.
+
+This tool takes 4 arguments:
+  * **locationUuid (string):** The unique identifier for the location.
+  * **componentEventTypes (array of strings, optional):** Array of event types to filter by. If empty or not provided, returns all event types.
+  * **startTime (string):** The timestamp (in ISO 8601 format) representing the start time of events.
+  * **endTime (string):** The timestamp (in ISO 8601 format) representing the end time of events.
+
+Valid event types include:
+  * **DoorbellEvent:** Doorbell button press events
+  * **CredentialReceivedEvent:** Badge/credential scans (NFC, BLE_WAVE, REMOTE unlocks)
+  * **DoorStateChangeEvent:** Door state changes (locked/unlocked)
+  * **ButtonEvent:** Generic button press events
+  * **PanicButtonEvent:** Panic/emergency button activations
+  * **DoorReaderStateChangeEvent:** Changes in door reader state
+  * **DoorRelayStateChangeEvent:** Changes in door relay state
+  * **AccessControlUnitTamperEvent:** Tamper detection events
+  * **AccessControlUnitBatteryStateChangeEvent:** Battery state changes
+  * **WaveToUnlockIntentExpiredEvent:** Wave-to-unlock timeout events
+  * **DoorAuthFirstInStateEvent:** First-in authentication state events
+  * **DoorScheduleFirstInStateEvent:** First-in schedule state events
+  * And more...
+
+When eventType is "camera":
+
+This tool retrieves human motion events detected by a specific camera within a time range. The data returned will have timestamps in milliseconds.
+
+This tool takes 3 arguments:
+  * **cameraUuid (string):** The unique identifier for the camera.
+  * **startTime (string):** The timestamp (in ISO 8601 format) representing the start time of events.
+  * **duration (number):** Duration in seconds to search for human motion events. Default is 3600 (1 hour).
+
+The tool returns a JSON object with camera events data.
+`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { eventType, accessControlledDoorUuids, deviceUuid, sensorUuid, locationUuid, componentEventTypes, startTime, endTime, limit, timeZone, tempUnit, cameraUuid, duration, } = args;
+    logger.debug(`eventType: ${eventType}`);
+    switch (eventType) {
+        case "access-control": {
+            if (!accessControlledDoorUuids || accessControlledDoorUuids.length === 0) {
+                const result = {
+                    needUserInput: true,
+                    commandForUser: "Which door are you asking about?",
+                };
+                return createToolStructuredContent(result);
+            }
+            else {
+                const events = await getAccessControlEvents(accessControlledDoorUuids, startTime ? new Date(startTime).getTime() : undefined, endTime ? new Date(endTime).getTime() : undefined, timeZone, extra._meta?.requestModifiers, extra.sessionId);
+                const result = {
+                    eventType: "access-control",
+                    accessControlEvents: events,
+                };
+                return createToolStructuredContent(result);
+            }
         }
-        if (eventType === "access-control") {
-            if (!accessControlledDoorUuid) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                needUserInput: true,
-                                commandForUser: "Which door are you asking about?",
-                            }),
-                        },
-                    ],
+        case "environmental-gateway": {
+            if (!deviceUuid) {
+                const result = {
+                    needUserInput: true,
+                    commandForUser: "Which environmental gateway device are you asking about?",
                 };
+                return createToolStructuredContent(result);
             }
             else {
-                const events = await getAccessControlEvents(accessControlledDoorUuid, extra._meta?.requestModifiers);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(events),
-                        },
-                    ],
+                const events = await getEventsForEnvironmentalGateway(deviceUuid, startTime ? new Date(startTime).getTime() : undefined, endTime ? new Date(endTime).getTime() : undefined, timeZone, tempUnit ?? TempUnit.CELSIUS, extra._meta?.requestModifiers, extra.sessionId);
+                const result = {
+                    eventType: "environmental-gateway",
+                    environmentalGatewayEvents: events,
                 };
+                return createToolStructuredContent(result);
             }
         }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({}),
-                },
-            ],
-        };
-    });
+        case "climate-sensor": {
+            if (!sensorUuid) {
+                const result = {
+                    needUserInput: true,
+                    commandForUser: "Which climate sensor are you asking about?",
+                };
+                return createToolStructuredContent(result);
+            }
+            else {
+                const events = await getClimateEventsForSensor(sensorUuid, startTime ? new Date(startTime).getTime() : undefined, endTime ? new Date(endTime).getTime() : undefined, limit ?? null, timeZone, tempUnit ?? TempUnit.CELSIUS, extra._meta?.requestModifiers, extra.sessionId);
+                const result = {
+                    eventType: "climate-sensor",
+                    climateSensorEvents: events,
+                };
+                return createToolStructuredContent(result);
+            }
+        }
+        case "component-events": {
+            if (!locationUuid) {
+                const result = {
+                    needUserInput: true,
+                    commandForUser: "Which location are you asking about?",
+                };
+                return createToolStructuredContent(result);
+            }
+            else {
+                const events = await getComponentEventsByLocation(locationUuid, componentEventTypes || [], startTime ? new Date(startTime).getTime() : undefined, endTime ? new Date(endTime).getTime() : undefined, timeZone, extra._meta?.requestModifiers, extra.sessionId);
+                const result = {
+                    eventType: "component-events",
+                    componentEvents: events,
+                };
+                return createToolStructuredContent(result);
+            }
+        }
+        case EventsToolRequestType.CAMERA: {
+            if (!cameraUuid) {
+                const result = {
+                    needUserInput: true,
+                    commandForUser: "Which camera are you asking about?",
+                };
+                return createToolStructuredContent(result);
+            }
+            else {
+                const events = await getHumanMotionEvents(cameraUuid, duration ?? 3600, // Default to 1 hour if not provided
+                startTime ? new Date(startTime).getTime() : Date.now() - 3600000, // Default to 1 hour ago if not provided
+                extra._meta?.requestModifiers, extra.sessionId);
+                return createToolStructuredContent({
+                    eventType: "camera",
+                    cameraEvents: events.uniqueHumanEvents,
+                });
+            }
+        }
+    }
+    // This should not happen, but return empty result if eventType is unknown
+    const result = {};
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+        ],
+        structuredContent: result,
+    };
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
 }

package/dist/tools/faces-tool.js

@@ -1,139 +1,66 @@
-import { z } from "zod";
-import { postApi } from "../network.js";
-var RequestType;
-(function (RequestType) {
-    RequestType["GET_FACE_EVENTS"] = "get-face-events";
-    RequestType["GET_REGISTERED_FACES"] = "get-registered-faces";
-})(RequestType || (RequestType = {}));
-// Zod Schema for 'get-registered-faces' arguments (no specific args)
-const GetRegisteredFacesArgsSchema = z.object({
-    requestType: z.literal(RequestType.GET_REGISTERED_FACES),
-});
-// --- GetFaceEventsArgs Schema ---
-// All 'get-face-events' specific arguments are directly in this object,
-// marked as nullable since they are conditional based on requestType.
-const GetFaceEventsArgs = z.object({
-    // Arguments for 'get-face-events' (flattened from original searchFilter)
-    deviceUuids: z
-        .array(z.string())
-        .optional()
-        .describe("Optional filter by a set of device UUIDs. Only face events from these devices will be returned. Applicable when requestType is 'get-face-events'."),
-    faceNameContains: z
-        .string()
-        .optional()
-        .describe("Optional filter for face events where the detected face's name contains this substring. The search is performed only if the value is at least 3 characters long after trimming spaces. This takes precedence over 'faceNames' if both are specified. Applicable when requestType is 'get-face-events'."),
-    faceNames: z
-        .array(z.string())
-        .optional()
-        .describe("Optional filter by a set of specific person names. Only face events associated with these names will be returned. Applicable when requestType is 'get-face-events'."),
-    hasEmbedding: z
-        .boolean()
-        .optional()
-        .describe("Optional filter by the presence (true) or absence (false) of a face embedding associated with the event. Applicable when requestType is 'get-face-events'."),
-    hasName: z
-        .boolean()
-        .optional()
-        .describe("Optional filter by the presence (true) or absence (false) of a person name associated with the face event. Applicable when requestType is 'get-face-events'."),
-    labels: z
-        .array(z.string())
-        .optional()
-        .describe("Optional filter by a set of labels associated with the face event. Applicable when requestType is 'get-face-events'."),
-    locationUuids: z
-        .array(z.string())
-        .optional()
-        .describe("Optional filter by a set of location UUIDs. Only face events from these locations will be returned. Applicable when requestType is 'get-face-events'."),
-    personUuids: z
-        .array(z.string())
-        .optional()
-        .describe("Optional filter by a set of person UUIDs. Only face events associated with these specific people will be returned. Applicable when requestType is 'get-face-events'."),
-    // Arguments for 'get-face-events' (flattened from original timestampFilter)
-    rangeEnd: z
-        .string()
-        .optional()
-        .describe("The end of the time range (inclusive) for filtering face events. Expected format is a string containing a timestamp in milliseconds since epoch. Applicable when requestType is 'get-face-events'. If not specified, the filter defaults to the last 7 days."),
-    rangeStart: z
-        .string()
-        .optional()
-        .describe("The start of the time range (inclusive) for filtering face events. Expected format is a string containing a timestamp in milliseconds since epoch. Applicable when requestType is 'get-face-events'. If not specified, the filter defaults to the last 7 days."),
-    // No specific arguments for 'get-registered-faces' beyond requestType itself.
-});
-// --- Extracted PostAPI Calls into Functions ---
-async function getFaceEvents(args, requestModifiers) {
-    // Directly pass the args object as requested by the user
-    return await postApi("/faceRecognition/faceEvent/findFaceEventsByOrg", args, requestModifiers);
-}
-async function getRegisteredFaces(args, requestModifiers) {
-    // No specific arguments for this API call, so send an empty object.
-    return await postApi("/faceRecognition/person/findPeopleByOrg", {}, requestModifiers);
-}
-// --- Main Tool Definition ---
-export function createTool(server) {
-    server.tool("faces-tool", `
-This tool interacts with the Rhombus face recognition system to retrieve information about face events and registered faces. It has two primary modes of operation, determined by the "requestType" parameter:
+import { getFaceEvents, getRegisteredFaces } from "../api/faces-tool-api.js";
+import { OUTPUT_SCHEMA, RequestType, TOOL_ARGS, } from "../types/faces-tools-types.js";
+import { extractFromToolExtra } from "../util.js";
+const TOOL_NAME = "faces-tool";
+// TODO: deviceUuids filter was removed, see TOOL_ARGS for reason
+const TOOL_DESCRIPTION = `
+This tool interacts with the Rhombus face recognition system to retrieve information about face sightings and registered faces. It has two primary modes of operation, determined by the "requestType" parameter:
 
-If the requestType is "get-face-events":
+It should only be used if someone is specifically asking about faces.  If they are asking about people or humans, you should use the events-tool with eventType "people" instead as this tool is for face sightings only.
 
-  This tool retrieves detailed face events recorded by your Rhombus cameras, such as detections and recognitions. It provides comprehensive information about each event, including details about the detected face, the person matched (if any), and the event context.
-
-  You can filter face events using parameters like 'deviceUuids', 'faceNameContains', 'faceNames', 'hasEmbedding', 'hasName', 'labels', 'locationUuids', 'personUuids', and a time range using 'rangeStart' and 'rangeEnd' (timestamps in milliseconds).
-
-  The tool returns a JSON object with the following structure and important fields:
-  * **lastEvaluatedKey (string | null):** A key for pagination; if not null, it can be used to retrieve the next page of results.
-  * **faceEvents (array of objects | null):** An array where each object represents a single face event. Each face event object contains the following important fields:
-      * **uuid (string):** The unique identifier for this specific face event.
-      * **eventTimestamp (int64):** The timestamp (in milliseconds since epoch) when the face event occurred.
-      * **faceName (string | null):** The name of the person that matched the face image, if a match was found.
-      * **personUuid (string | null):** The UUID of the person that matched the face image, if a match was found.
-      * **deviceUuid (string):** The UUID of the device (e.g., camera) where the face event was detected.
-      * **locationUuid (string | null):** The UUID of the location where the face event occurred.
-      * **orgUuid (string | null):** The UUID of the organization associated with the event.
-      * **detectionConfidence (float | null):** A confidence value (between 0.0 and 1.0) indicating the likelihood that the detected image is a face.
-      * **thumbnailS3Key (string | null):** The S3 key for accessing the thumbnail image of the detected face.
-      * **selectedPersonMatch (object | null):** An object containing details about the top person match found for the face image, if any. Important fields within this object include:
-          * **confidence (float | null):** The match confidence level, expressed as a value in the range [0,1].
-          * **faceId (string | null):** The face ID of the matched person.
-          * **name (string | null):** The name of the matched person.
-          * **uuid (string | null):** The UUID of the matched person.
+If the requestType is "get-face-events":
+- Use this tool to answer questions about face sightings, including questions like "who was in the office" or "who was seen today".  Can be used for reporting, to generate a report on who was seen by the camera system.
+- This tool retrieves detailed face events such as detections and recognitions. It provides comprehensive information about each event, including details about the detected face, the person matched (if any), and the event context.
+- You can filter face events using parameters like 'faceNames', 'hasEmbedding', 'hasName', 'labels', 'locationUuids', 'personUuids', and a time range using 'rangeStart' and 'rangeEnd' (timestamps in milliseconds).
+- If you'd like to know about all face events at a location, pass in a location UUID and no device UUIDs. This will correctly return all face events at that location.
 
 If the requestType is "get-registered-faces":
-
-  This tool retrieves a list of all people (registered faces) currently known to the Rhombus system for your organization. This list includes information about each registered person.
-
-  This tool takes no arguments.
-
-  The tool returns a JSON object with the following structure and important fields:
-  * **people (array of objects | null):** An array where each object represents a registered person. Each person object contains the following important fields:
-      * **uuid (string):** The unique identifier for the registered person.
-      * **name (string | null):** The name associated with the registered person.
-      * **createdOn (date-time | null):** The date and time when the person was registered.
-      * **updatedOn (date-time | null):** The date and time when the person's information was last updated.
-      * **orgUuid (string | null):** The UUID of the organization to which the person belongs.
-
-`, 
-    // FacesToolArgs directly passed here
-    {
-        requestType: z.nativeEnum(RequestType),
-        args: z.union([
-            z.object({
-                args: GetFaceEventsArgs,
-            }),
-            z.object({
-                requestType: z.literal(RequestType.GET_REGISTERED_FACES),
-                args: GetRegisteredFacesArgsSchema,
-            }),
-        ]),
-    }, async ({ requestType, args }, extra) => {
-        let ret;
-        if (requestType === "get-face-events") {
-            // Pass the args directly, as requested
-            ret = await getFaceEvents(args, extra._meta?.requestModifiers);
+- This tool retrieves a list of all people (registered faces) currently known to the Rhombus system for your organization. This list includes information about each registered person.
+- this returns ALL people registered in the system, regardless of the provided timestampFilter.
+- This is useful to call before calling "get-face-events" to get a list of all people that have been seen by the camera system, and then you can use personUuids or the name *in the system* to filter face events.
+`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
+    let ret = {
+        requestType: args.requestType,
+    };
+    if (args.requestType === RequestType.GET_FACE_EVENTS) {
+        const response = await getFaceEvents(args.faceEventFilter, args.timeZone, requestModifiers, sessionId);
+        ret = {
+            requestType: RequestType.GET_FACE_EVENTS,
+            getFaceEventsResponse: response,
+        };
+    }
+    else if (args.requestType === RequestType.GET_REGISTERED_FACES) {
+        const response = await getRegisteredFaces(args, requestModifiers, sessionId);
+        if (response.people) {
+            ret = {
+                requestType: RequestType.GET_REGISTERED_FACES,
+                getSavedFacesResponse: response.people.map(p => ({
+                    createdOn: p.createdOn ? parseInt(p.createdOn, 10) : undefined,
+                    name: p.name ?? undefined,
+                    orgUuid: p.orgUuid ?? undefined,
+                    updatedOn: p.updatedOn ? parseInt(p.updatedOn, 10) : undefined,
+                    uuid: p.uuid ?? undefined,
+                })),
+            };
         }
-        else if (requestType === "get-registered-faces") {
-            // Pass the args (will effectively be an empty object for this call)
-            ret = await getRegisteredFaces(args, extra._meta?.requestModifiers);
+        else {
+            ret = {
+                requestType: RequestType.GET_REGISTERED_FACES,
+                error: String(response.error),
+            };
         }
-        return {
-            content: [{ type: "text", text: JSON.stringify(ret) }],
-        };
-    });
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(ret) }],
+        structuredContent: ret,
+    };
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
 }