rhombus-node-mcp 0.1.13 → 0.1.16

package/dist/types.js

@@ -1,22 +1,32 @@
 import { z } from "zod";
-export const UUID = z
-    .string()
-    .describe("This describes the UUID of some entity (device, location, etc.) and is unique and must come from data. This can not be fabricated. It is always 22 characters long");
+export function createUuidSchema() {
+    return z
+        .string()
+        .length(22)
+        // .regex(/[A-Za-z0-9\\-_]{22}/)
+        .describe(`This describes the UUID of some entity (device, location, etc.) and is unique and must come from data.
+      This can not be fabricated. It is always 22 characters long. Truncate any facet ids, such as .v0.
+      It contains only alphanumeric characters, digits, hyphens, and underscores.`);
+}
+export const UUID = createUuidSchema();
 export const VideoWallSettings = z.object({
     rowCount: z.number(),
     columnCount: z.number(),
-    intervalSeconds: z.number().optional(),
+    intervalSeconds: z.number().nullable(),
     rotateStrategy: z.enum(["none", "motion", "interval"]),
 });
 export const CreateVideoWallOptions = z
     .object({
-    displayName: z.string().optional().describe("What to call the video wall"),
+    displayName: z.string().nullable().describe("What to call the video wall"),
     orgUuid: z.string().describe("The uuid of the organization"),
     deviceList: z
         .array(z.string())
         .min(1)
         .describe("The list of camera uuids (unique identifiers) to exist in the video wall.  You must provide this manually by prompting the user at least once."),
-    othersCanEdit: z.boolean().optional().describe("Whether or not other users can edit the wall, defaults to false"),
+    othersCanEdit: z
+        .boolean()
+        .nullable()
+        .describe("Whether or not other users can edit the wall, defaults to false"),
     settings: VideoWallSettings,
 })
-    .optional();
+    .nullable();

package/dist/util.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import fs from "fs";
 import path from "path";
+import { DateTime } from "luxon";
 export function generateRandomString(length) {
     const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
     let result = "";
@@ -10,14 +11,19 @@ export function generateRandomString(length) {
     }
     return result;
 }
-const STATIC_ARGS = {
-    requestModifiers: z
-        .optional(z.object({
-        headers: z.nullable(z.record(z.string(), z.string())),
-        query: z.nullable(z.record(z.string(), z.string())),
-    }))
-        .describe("Optional headers accepted by tools.  LLM should never ever use this. 😅"),
-};
+export const RequestModifiers = z
+    .object({
+    headers: z.optional(z.record(z.string(), z.string())),
+    query: z.optional(z.record(z.string(), z.string())),
+})
+    .optional();
+export function extractFromToolExtra(_extra) {
+    const extra = _extra;
+    return {
+        requestModifiers: extra._meta?.requestModifiers,
+        sessionId: extra.sessionId,
+    };
+}
 /**
  * Get all file paths in a directory in a directory
  *
@@ -46,12 +52,6 @@ export function getFilePathsInDirectory(dirPath) {
     }
     return filePaths;
 }
-export function createToolArgs(args) {
-    return {
-        ...args,
-        ...STATIC_ARGS,
-    };
-}
 /**
  * Returns an object in the form expected by `server.tool`
  */
@@ -65,6 +65,21 @@ export function createToolTextContent(content) {
         ],
     };
 }
+/**
+ * Returns strucutred content expected by `server.tool`
+ * The generic type T allows for type safety. Set T to the output schema of the tool, and your content will be type checked
+ */
+export function createToolStructuredContent(content) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(content),
+            },
+        ],
+        structuredContent: content,
+    };
+}
 /**
  * Recursively removes fields with null values from a JavaScript object.
  * If a nested object becomes empty after removing nulls, it will also be removed.
@@ -109,3 +124,70 @@ export function removeNullFields(obj) {
     }
     return Object.keys(cleanedObject).length > 0 ? cleanedObject : undefined;
 }
+export function filterIncludedFields(obj, fieldsToInclude) {
+    if (!fieldsToInclude || fieldsToInclude.length === 0) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj
+            .map(item => filterIncludedFields(item, fieldsToInclude))
+            .filter(item => {
+            if (item === undefined || item === null) {
+                return false;
+            }
+            if (Array.isArray(item)) {
+                return item.length > 0;
+            }
+            if (typeof item === "object") {
+                return Object.keys(item).length > 0;
+            }
+            // Keep primitives
+            return true;
+        });
+    }
+    if (typeof obj === "object" && obj !== null) {
+        const newObj = {};
+        for (const key in obj) {
+            if (Object.prototype.hasOwnProperty.call(obj, key)) {
+                if (fieldsToInclude.includes(key)) {
+                    newObj[key] = obj[key];
+                }
+                else {
+                    const result = filterIncludedFields(obj[key], fieldsToInclude);
+                    if (result !== undefined && result !== null) {
+                        if (Array.isArray(result)) {
+                            if (result.length > 0) {
+                                newObj[key] = result;
+                            }
+                        }
+                        else if (typeof result === "object") {
+                            if (Object.keys(result).length > 0) {
+                                newObj[key] = result;
+                            }
+                        }
+                        else {
+                            newObj[key] = result;
+                        }
+                    }
+                }
+            }
+        }
+        return Object.keys(newObj).length > 0 ? newObj : undefined;
+    }
+    return undefined;
+}
+/**
+ * Formats a timestamp in milliseconds to a human-readable date string
+ * Format: "February 24, 2025 at 3:23 PM"
+ *
+ * @param timestampMs - Timestamp in milliseconds
+ * @param timeZone - Optional IANA timezone string (defaults to "America/Los_Angeles")
+ * @returns Formatted date string
+ */
+export function formatTimestamp(timestampMs, timeZone) {
+    return DateTime.fromMillis(timestampMs)
+        .setZone(timeZone || "America/Los_Angeles")
+        .toFormat("MMMM d, yyyy 'at' h:mm:ss a", {
+        locale: "en-US",
+    });
+}

package/dist/utils/confirmation.js

@@ -4,14 +4,8 @@
 import { z } from "zod";
 import { createToolTextContent, generateRandomString } from "../util.js";
 import { logger } from "../logger.js";
-// export function createToolArgs<TArgs extends object>(args: TArgs): TArgs & typeof STATIC_ARGS {
-//     return {
-//       ...args,
-//       ...STATIC_ARGS,
-//     };
-//   }
 export const CONFIRMATION_ARGS = {
-    confirmationId: z.string().nullable().optional(),
+    confirmationId: z.string().nullable(),
 };
 export function addConfirmationParams(args) {
     return {

package/dist/utils/reduce-output.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+export const REDUCE_OUTPUT_ARGS = {
+    includeFields: z
+        .array(z.string())
+        .describe("The fields to include in the response."),
+};
+export function addReduceOutputParams(args) {
+    return {
+        ...args,
+        ...REDUCE_OUTPUT_ARGS,
+    };
+}
+export function generateEndpointToKeysWorkflowText(endpointMap) {
+    const endpointList = Object.entries(endpointMap)
+        .map(([entityType, endpoint]) => `- ${entityType}: ${endpoint}`)
+        .join('\n');
+    // Automatically generate example from first entry in the map
+    const [firstEntityType, firstEndpoint] = Object.entries(endpointMap)[0];
+    const exampleEntityTypeName = firstEntityType.toLowerCase().replace(/_/g, ' ');
+    const exampleFields = ["field1", "field2", "field3"];
+    return `IMPORTANT: Before using this tool, you MUST first use the endpoint-to-keys-tool to get the available output fields for the relevant endpoints, then specify the fields you want in the includeFields parameter to reduce context size.
+
+The following endpoints are called for each device type:
+${endpointList}
+
+REQUIRED WORKFLOW:
+1. First call endpoint-to-keys-tool with the relevant endpoint(s) above, if the endpoint is not found, you can proceed to this tool with an empty includeFields parameter.
+2. Then call this tool with the specific fields you need in includeFields parameter
+
+Example for ${exampleEntityTypeName}s: 
+1. Call endpoint-to-keys-tool with "${firstEndpoint}"
+2. Use the returned keys to populate includeFields (e.g., ${JSON.stringify(exampleFields)})
+
+Always use includeFields to limit the response size and get only the data you need.`;
+}

package/dist/utils/remove-nulls.js

@@ -0,0 +1,28 @@
+/**
+ * Remove all null values from an object.
+ * @param obj - The object to remove null values from.
+ * @returns A new object with all null values removed.
+ */
+export function removeNulls(obj) {
+    // Create a shallow copy to avoid modifying the original object
+    const copy = { ...obj };
+    for (const key in copy) {
+        if (Object.prototype.hasOwnProperty.call(copy, key)) {
+            const value = copy[key];
+            if (value === null) {
+                delete copy[key];
+            }
+            else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+                // Recursively clean nested objects
+                const cleaned = removeNulls(value);
+                if (Object.keys(cleaned).length === 0) {
+                    delete copy[key];
+                }
+                else {
+                    copy[key] = cleaned;
+                }
+            }
+        }
+    }
+    return copy;
+}

package/dist/utils/temp.js

@@ -0,0 +1,8 @@
+export var TempUnit;
+(function (TempUnit) {
+    TempUnit["CELSIUS"] = "C";
+    TempUnit["FAHRENHEIT"] = "F";
+})(TempUnit || (TempUnit = {}));
+export function tempFunc(temp, tempUnit) {
+    return tempUnit === TempUnit.FAHRENHEIT ? (temp * 9) / 5 + 32 : temp;
+}

package/dist/utils/timestampInput.js

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+export const ISOTimestampFormatDescription = 'Time format is in ISO 8601 format. Both UTC ("2025-08-04T20:54:27.123Z") and time zone offsets ("2025-08-04T13:54:27.123-07:00") are accepted to ensure an unambiguous point in time.';
+export const createEpochSchema = () => {
+    return z.coerce.date({
+        errorMap: (issue, ctx) => {
+            if (issue.code === 'invalid_date') {
+                return { message: 'Invalid datetime string. Expected ISO 8601 format.' };
+            }
+            return { message: ctx.defaultError };
+        },
+    }).transform(date => date.getTime());
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.13",
+  "version": "0.1.16",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",
@@ -24,24 +24,49 @@
     "mcp-server-rhombus": "dist/index.js"
   },
   "scripts": {
-    "build": "tsc && chmod +x dist/*.js",
+    "build": "rm -rf dist && tsc && chmod +x dist/*.js",
     "prepare": "npm run build",
-    "watch": "tsc --watch"
+    "watch": "tsc --watch",
+    "generate-schemas": "npx tsx scripts/generate-zod-schemas.ts",
+    "scrape-sitemaps": "npx tsx scripts/scrape-sitemaps.ts",
+    "scrape-content": "npx tsx scripts/scrape-content.ts",
+    "scrape-progress": "npx tsx scripts/scrape-content.ts --progress",
+    "generate-embeddings": "npx tsx scripts/generate-embeddings.ts",
+    "embedding-progress": "npx tsx scripts/generate-embeddings.ts --progress",
+    "estimate-cost": "npx tsx scripts/generate-embeddings.ts --estimate-only",
+    "build-faiss-index": "npx tsx scripts/build-faiss-index.ts",
+    "extract-route-outputs": "npx tsx assets/extract-route-outputs.ts",
+    "create:tool": "tsx scripts/create-new-tool.ts"
   },
   "files": [
     "dist"
   ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.9.0",
+    "axios": "^1.11.0",
+    "cheerio": "^1.1.2",
     "chrono-node": "^2.8.0",
+    "cors": "^2.8.5",
     "dotenv": "^16.5.0",
+    "express": "^5.1.0",
+    "express-jwt": "^8.5.1",
+    "faiss-node": "^0.5.1",
+    "jsonwebtoken": "^9.0.2",
+    "langchain": "^0.3.30",
     "log4js": "^6.9.1",
     "luxon": "^3.6.1",
+    "openai": "^5.12.1",
+    "tiktoken": "^1.0.21",
     "zod": "^3.24.2"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/jwt-express": "^1.1.6",
     "@types/luxon": "^3.6.2",
     "@types/node": "^22.14.0",
+    "openapi-typescript-codegen": "^0.29.0",
+    "openapi-zod-client": "^1.17.0",
     "prettier": "3.5.3",
     "typescript": "^5.8.3"
   },

package/dist/tools/devices/camera-tool/camera-tool.js

@@ -1,218 +0,0 @@
-import { z } from "zod";
-import { getLogger } from "../../../logger.js";
-import { appendQueryParams, AUTH_HEADERS, postApi, STATIC_HEADERS } from "../../../network.js";
-import { createToolArgs, createToolTextContent, removeNullFields, } from "../../../util.js";
-import { addConfirmationParams, isConfirmed, requireConfirmation, } from "../../../utils/confirmation.js";
-import { ExternalUpdateableFacetedUserConfigSchema, } from "./types.js";
-const logger = getLogger("camera-tool");
-async function getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers) {
-    const body = {
-        cameraUuid: cameraUuid,
-        downscaleFactor: 10,
-        jpgQuality: 70,
-        permyriadCropHeight: 10000,
-        permyriadCropWidth: 5625,
-        permyriadCropX: 2188,
-        permyriadCropY: 0,
-        timestampMs: timestampMs,
-    };
-    logger.debug(`Getting frameUri from UUID: ${cameraUuid} at timestampMs: ${timestampMs}`);
-    const base64Image = await postApi("/video/getExactFrameUri", body, requestModifiers).then(async (res) => {
-        logger.debug(`Received frameUri ${res.frameUri}`);
-        // construct request headers
-        let requestHeaders = {
-            ...(requestModifiers?.headers ?? AUTH_HEADERS),
-            ...STATIC_HEADERS,
-        };
-        // add query params
-        if (requestModifiers?.query) {
-            res.frameUri = appendQueryParams(res.frameUri, requestModifiers.query);
-        }
-        logger.trace(`Fetching with headers\n${JSON.stringify(requestHeaders)}`);
-        return await fetch(res.frameUri, {
-            method: "GET",
-            headers: requestHeaders,
-        }).then(async (res) => {
-            if (!res.ok) {
-                logger.error(`Failed to fetch image: ${await res.text()}`);
-                logger.error(res);
-                return null;
-            }
-            const arrayBuffer = await res.arrayBuffer();
-            const buffer = Buffer.from(arrayBuffer);
-            const base64 = buffer.toString("base64");
-            return base64;
-        });
-    });
-    if (!base64Image) {
-        return {
-            success: false,
-            status: "failed to fetch image",
-        };
-    }
-    return {
-        success: true,
-        status: "successfully fetched image",
-        imageType: "base64",
-        imageData: base64Image,
-    };
-}
-export async function getCameraSettings(cameraUuid, requestModifiers) {
-    const res = await postApi("/camera/getFacetedConfig", {
-        deviceUuid: cameraUuid,
-    }, requestModifiers);
-    if (res.error) {
-        return {
-            success: false,
-            status: "failed to fetch camera settings",
-        };
-    }
-    return {
-        success: true,
-        config: res.config,
-        status: "fetched camera settings",
-    };
-}
-export async function updateCameraSettings(cameraUuid, update, requestModifiers) {
-    // remove any "null" values
-    const res = await postApi("/camera/updateFacetedConfig", {
-        configUpdate: {
-            deviceUuid: cameraUuid,
-            ...removeNullFields(update),
-        },
-    }, requestModifiers);
-    if (res.error) {
-        return {
-            success: false,
-            status: "failed to update camera settings",
-        };
-    }
-    return {
-        success: true,
-        config: res.config,
-        status: "updated camera settings",
-    };
-}
-export function createTool(server) {
-    server.tool("camera-tool", `
-This tool can perform some action pertaining to the video stream of a camera. There are three types of requests
-that can be passed into "requestType":
-- image
-- get-settings
-- update-settings
-
-What follows is a description of the behavior of this tool given the requestType
-
-If the requestType is "image":
-
-This tool captures and returns a real-time snapshot from a designated security camera.
-The image reflects the current scene in the camera\'s field of view and serves as a contextual
-input source for downstream tasks such as object recognition, anomaly detection, incident investigation,
-or situational assessment. When invoked, the tool provides the following: \n
- •  Visual Scene Capture: A high-resolution image of what the camera is actively observing, including people, vehicles, license plates, and any detectable objects. \n
- •  Enriched Data Potential: The image can be paired with AI models or downstream analytics to extract insights such as: \n•  Number and type of objects in frame (e.g., humans, cars, packages) \n•  Unusual behaviors (e.g., loitering, unauthorized access) \n•  Environmental conditions (e.g., lighting, obstruction, cleanliness) \nUse Cases: \n•  Verify what triggered a motion alert or analytic rule. \n•  Provide visual context for access events or alarms. \n• Support live incident triage or retrospective investigations. \n• Feed contextual imagery to agents making security or operational decisions. \nInvocation Notes: \nTo use this tool correctly, the agent should provide the specific camera identifier or location name. If possible, include the intent (e.g., "verify unauthorized access", "identify vehicle", "check for obstructions") to enhance downstream processing or summarization.
- 
-If the requestType is "get-settings":
-
-THIS TOOL UPDATES AND SETS DATA.
-
-This tool retrieves the current configuration for a specified camera or associated device (e.g., sensor, access controller). The returned JSON object can include detailed camera settings (e.g., resolution, bitrate) and various device-specific configurations.
-Use Cases: Retrieve the current resolution of Camera A.
-
-If the requestType is "update-settings":
-
-THIS TOOL UPDATES AND SETS DATA.
-
-You can call call this tool with requestType "get-settings" and/or with "image" first to get a better idea of what needs to be updated.
-This tool updates the configuration for a camera or associated device using the "configUpdate" parameter, which must be a JSON object containing the specific fields and their new values. For example, you can modify streaming parameters.
-Thus, "configUpdate' is a necessary parameter if updating settings.
-Please make sure you only update the necessary fields, since any unnecessary changes may cause the camera to behave improperly.
-It may be a good idea to call "image" on this tool again after updating settings to make sure the new settings were effective in fulfilling
-the user's request.
-Use Cases: Adjust streaming parameters for Camera E.
-`, addConfirmationParams(createToolArgs({
-        requestType: z.enum(["image", "get-settings", "update-settings"]),
-        timestampMs: z.optional(z.number()).describe(`
-          the timestamp in milliseconds. You can default to the current time if the user didn't specify a time, or you can call time-tool to parse the user's time description
-          `),
-        cameraUuid: z.optional(z.string()).describe("the camera uuid requested"),
-        configUpdate: ExternalUpdateableFacetedUserConfigSchema.optional().describe('the config update that would be applied to the camera if the requestType is "update-settings"'),
-    })), async ({ cameraUuid, timestampMs, requestType, configUpdate, requestModifiers, confirmationId, }) => {
-        if (!cameraUuid) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            needUserInput: true,
-                            commandForUser: "Which camera are you talking about?",
-                        }),
-                    },
-                ],
-            };
-        }
-        let response;
-        switch (requestType) {
-            case "image":
-                if (!timestampMs) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: JSON.stringify({
-                                    needUserInput: true,
-                                    commandForUser: "At what time?",
-                                }),
-                            },
-                        ],
-                    };
-                }
-                response = await getImageForCameraAtTime(cameraUuid, timestampMs, requestModifiers);
-                if (!response.success || !response.imageData) {
-                    return {
-                        content: [{ type: "text", text: JSON.stringify(response) }],
-                    };
-                }
-                return {
-                    content: [
-                        {
-                            type: "image",
-                            data: response.imageData,
-                            mimeType: "image/jpeg",
-                        },
-                    ],
-                };
-            case "get-settings":
-                response = await getCameraSettings(cameraUuid, requestModifiers);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response) }],
-                };
-            case "update-settings":
-                const confirmation = requireConfirmation(confirmationId);
-                if (!isConfirmed(confirmation)) {
-                    return confirmation;
-                }
-                if (!configUpdate) {
-                    return createToolTextContent("Missing configUpdate");
-                }
-                response = await updateCameraSettings(cameraUuid, configUpdate, requestModifiers);
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response) }],
-                };
-            default:
-                response = {
-                    error: true,
-                    status: "missing unknown type from tool call",
-                };
-                break;
-        }
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({ response }),
-                },
-            ],
-        };
-    });
-}