rhombus-node-mcp 0.1.15 → 0.1.16

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

@@ -0,0 +1,78 @@
+import { getAccessControlledDoors, getAudioGateways, getBadgeReaders, getButtons, getCameraList, getDoorbellCameras, getDoorSensors, getEnvironmentalGateways, getEnvironmentalSensors, getKeypads, getMotionSensors, } from "../api/get-entity-tool-api.js";
+import DeviceType from "../types/deviceType.js";
+import { TOOL_ARGS } from "../types/get-entity-tool-types.js";
+import { createToolTextContent, extractFromToolExtra } from "../util.js";
+const TOOL_NAME = "get-entity-tool";
+const TOOL_DESCRIPTION = `
+Retrieves entities (or devices) of certain types.
+Can request multiple entity types at once.
+The return structure is a JSON string that contains the states of the requested entities.
+This data is exact. Whatever entities exist will be returned here.`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { entityTypes, timeZone, filterBy, tempUnit } = args;
+    const { requestModifiers, sessionId } = extractFromToolExtra(extra);
+    const promises = [];
+    if (entityTypes.includes(DeviceType.CAMERA)) {
+        promises.push(getCameraList(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.DOORBELL_CAMERA)) {
+        promises.push(getDoorbellCameras(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.BADGE_READER)) {
+        promises.push(getBadgeReaders(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.ACCESS_CONTROL_DOOR)) {
+        promises.push(getAccessControlledDoors(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.AUDIO_GATEWAY)) {
+        promises.push(getAudioGateways(timeZone, requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.DOOR_SENSOR)) {
+        promises.push(getDoorSensors(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.ENVIRONMENTAL_SENSOR)) {
+        promises.push(getEnvironmentalSensors(timeZone, tempUnit, requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.MOTION_SENSOR)) {
+        promises.push(getMotionSensors(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.BUTTON)) {
+        promises.push(getButtons(timeZone, requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.KEYPAD)) {
+        promises.push(getKeypads(requestModifiers, sessionId));
+    }
+    if (entityTypes.includes(DeviceType.ENVIRONMENTAL_GATEWAY)) {
+        promises.push(getEnvironmentalGateways(timeZone, requestModifiers, sessionId));
+    }
+    const responses = await Promise.all(promises);
+    // apply filters
+    for (let i = 0; i < responses.length; i++) {
+        const response = responses[i];
+        // look through keys and find any with an array
+        for (const key of Object.keys(response)) {
+            const value = response[key];
+            if (Array.isArray(value)) {
+                // then filter
+                response[key] = value.filter((item) => {
+                    let pass = true;
+                    if (item.locationUuid && filterBy.locationUuids && filterBy.locationUuids.length > 0) {
+                        pass = pass && filterBy.locationUuids.includes(item.locationUuid);
+                    }
+                    return pass;
+                });
+                response[`${key}Count`] = response[key].length;
+            }
+        }
+    }
+    const ret = {
+        ...responses.reduce((prev, curr) => ({
+            ...prev,
+            ...curr,
+        }), {}),
+    };
+    return createToolTextContent(JSON.stringify(ret));
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/tools/get-org-information-tool.js

@@ -0,0 +1,18 @@
+import { getOrg } from "../api/get-org-information-tool-api.js";
+import { TOOL_ARGS } from "../types/get-org-information-tool-types.js";
+const TOOL_NAME = "get-org-information";
+const TOOL_DESCRIPTION = "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.";
+const TOOL_HANDLER = async (args, extra) => {
+    const org = await getOrg(extra._meta?.requestModifiers, extra.sessionId);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(org),
+            },
+        ],
+    };
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/tools/location-tool.js

@@ -1,33 +1,26 @@
-import { z } from "zod";
-import { postApi } from "../network.js";
-async function getLocations(requestModifiers) {
-    return await postApi("/location/getLocationsV2", {}, requestModifiers);
-}
+import { getLocations } from "../api/location-tool-api.js";
+import { TOOL_ARGS } from "../types/location-tool-types.js";
+const TOOL_NAME = "location-tool";
+const TOOL_DESCRIPTION = `This tool performs operations on locations.
+- 'get': Retrieves all locations.`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { action } = args;
+    let ret;
+    switch (action) {
+        case "get":
+            ret = await getLocations(extra._meta?.requestModifiers, extra.sessionId);
+            break;
+        case "update":
+            ret = { error: true, status: "not implemented" };
+            break;
+        default:
+            ret = { error: true, status: `unsupported location tool call: ${action}` };
+            break;
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(ret) }],
+    };
+};
 export function createTool(server) {
-    server.tool("location-tool", `This tool performs operations on locations.
-- 'get': Retrieves all locations.`, {
-        action: z.enum(["get", "update"]),
-        locationUpdate: z
-            .object({
-            uuid: z.string(),
-            name: z.string(),
-        })
-            .optional(),
-    }, async ({ action }, extra) => {
-        let ret;
-        switch (action) {
-            case "get":
-                ret = await getLocations(extra._meta?.requestModifiers);
-                break;
-            case "update":
-                ret = { error: true, status: "not implemented" };
-                break;
-            default:
-                ret = { error: true, status: `unsupported location tool call: ${action}` };
-                break;
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(ret) }],
-        };
-    });
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
 }

package/dist/tools/lpr-tool.js

@@ -0,0 +1,71 @@
+import { getSavedVehicles, getVehicleEvents, getVehicleLabels } from "../api/lpr-tool-api.js";
+import { LprToolRequestType, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/lpr-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "lpr-tool";
+const TOOL_DESCRIPTION = `
+This tool interacts with the Rhombus LPR system to retrieve information about license plate recognition events and registered license plates.
+
+The system's cameras may have LPR enabled, and when it is enabled, it will detect "license plate recognition" events when it sees a license plate
+come into view. However, it is possible that the recognized license is only a partial match, so keep that in mind when using this tool.
+Users will be able to save license plates into the system, and then additionally label them with a name.
+
+This tool has 3 modes of operation, determined by the "requestType" parameter:
+- ${LprToolRequestType.GET_VEHICLE_EVENTS}: Retrieves a list of vehicle events that have been detected by the system. Please keep in mind that this has the *potential*
+  to return a lot of data. However, 7 days should be a reasonable time range to start from if the user is not specific.
+- ${LprToolRequestType.GET_SAVED_VEHICLES}: Retrieves a list of saved vehicles that have been saved in the organization.
+- ${LprToolRequestType.GET_VEHICLE_LABELS}: Retrieves a list of vehicle labels that have been saved in the organization.
+
+Its very likely that "vehicle", "car", and "license plates" are used interchangeably. Please keep this in mind.
+`;
+const TOOL_HANDLER = async (args, _extra) => {
+    const responseType = args.requestType;
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (responseType) {
+            case LprToolRequestType.GET_VEHICLE_EVENTS: {
+                const { vehicleEventsArgs } = args;
+                if (!vehicleEventsArgs) {
+                    return createToolTextContent(JSON.stringify({
+                        error: "vehicleEventsArgs is required. Please try again.",
+                    }));
+                }
+                const vehicleEvents = await getVehicleEvents(vehicleEventsArgs, args.timeZone, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    vehicleEvents,
+                });
+            }
+            case LprToolRequestType.GET_SAVED_VEHICLES: {
+                const savedVehicles = await getSavedVehicles(args.timeZone, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    savedVehicles,
+                });
+            }
+            case LprToolRequestType.GET_VEHICLE_LABELS: {
+                const vehicleLabels = await getVehicleLabels(requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    vehicleLabels,
+                });
+            }
+        }
+    }
+    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/policy-alerts-tool.js

@@ -1,35 +1,7 @@
-import { z } from "zod";
-import { postApi } from "../network.js";
-const PolicyAlertsArgs = z.object({
-    afterTimestampMs: z
-        .number()
-        .optional()
-        .describe("The start of the time range (in milliseconds since epoch) for which to retrieve alerts. Only alerts that occurred AFTER this timestamp will be returned."),
-    beforeTimestampMs: z
-        .number()
-        .optional()
-        .describe("The end of the time range (in milliseconds since epoch) for which to retrieve alerts. Only alerts that occurred BEFORE this timestamp will be returned."),
-    deviceFilter: z
-        .array(z.string())
-        .optional()
-        .describe("A list of UUIDs representing the specific devices to filter alerts by. Only alerts emitted by these devices will be returned."),
-    locationFilter: z
-        .array(z.string())
-        .optional()
-        .describe("A list of UUIDs representing the specific locations to filter alerts by. Only alerts associated with these locations will be returned."),
-    maxResults: z
-        .number()
-        .optional()
-        .describe("The maximum number of policy alerts to return. The system may default to a reasonable number (e.g., 20) if not specified, but there is a hard cap (e.g., 100) on the maximum results the API will return."),
-    // these may be pagination args, we'll leave them out for now
-    // lastTimestampMs: z.number().optional(),
-    // lastUuid: z.number().optional(),
-});
-async function getPolicyAlerts(args, requestModifiers) {
-    return await postApi("/event/getPolicyAlertsV2", args, requestModifiers);
-}
-export function createTool(server) {
-    server.tool("policy-alerts-tool", `
+import { getExpiringPolicyAlerts, getPolicyAlerts } from "../api/policy-alerts-tool-api.js";
+import { ApiPayloadSchema, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/policy-alerts-tool-types.js";
+const TOOL_NAME = "policy-alerts-tool";
+const TOOL_DESCRIPTION = `
 Retrieves Rhombus policy alerts. Policy alerts in the Rhombus system are generated based on user-defined alert
 policies configured in the Rhombus Console. These policies trigger alerts when specific events occur, such as:
 * AI & Computer Vision Events: Based on intelligent video analytics for motion, people, vehicles, facial recognition,
@@ -38,19 +10,37 @@ policies configured in the Rhombus Console. These policies trigger alerts when s
 * Physical or Visual Tamper: Detection of physical movement of a device or obstruction of a camera's field of view.
 * Access Control Events: Such as unauthorized access attempts in restricted areas.
 
+Can inquire about labels that have been seen.
+
 Please note, this is not an exhaustive list, and there may be other types of triggers or events that generate
 policy alerts within the Rhombus system.
 
-This tool allows you to filter existing alerts by a specific time range (before or after a timestamp in milliseconds),
+This tool allows you to filter existing alerts by existing/expiring, a specific time range (before or after a timestamp in ISO 8601 format),
 by a list of device UUIDs, or by a list of location UUIDs.
 You can also specify the maximum number of results to return.
-The output is provided in JSON format.`, {
-        ...PolicyAlertsArgs.shape,
-    }, async ({ ...args }, extra) => {
-        let ret;
-        ret = await getPolicyAlerts(args, extra._meta?.requestModifiers);
-        return {
-            content: [{ type: "text", text: JSON.stringify(ret) }],
-        };
-    });
+The output is provided in JSON format.`;
+const TOOL_HANDLER = async (args, extra) => {
+    const payload = ApiPayloadSchema.parse(args);
+    let ret;
+    switch (args.queryType) {
+        case "existing":
+            ret = await getPolicyAlerts(payload, extra._meta?.requestModifiers, extra.sessionId);
+            break;
+        case "expiringSoon":
+            await getExpiringPolicyAlerts(payload, extra._meta?.requestModifiers, extra.sessionId);
+            break;
+        default:
+            throw new Error(`Unsupported queryType: ${args.queryType}`);
+    }
+    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);
 }

package/dist/tools/reboot-cameras-tool.js

@@ -0,0 +1,34 @@
+import { isConfirmed, requireConfirmation } from "../utils/confirmation.js";
+import { rebootCameras } from "../api/reboot-cameras-tool-api.js";
+import { TOOL_ARGS } from "../types/reboot-cameras-tool-types.js";
+const TOOL_NAME = "reboot-cameras";
+const TOOL_DESCRIPTION = "this tool is for rebooting one or more cameras causing them to reconnect to the server, this is a helpful option when a camera is experiencing connectivity issues or is in need of troubleshooting. THIS TOOL PERFORMS AN ACTION.";
+const TOOL_HANDLER = async (args, extra) => {
+    const { cameraUuids, confirmationId } = args;
+    const confirmation = requireConfirmation(confirmationId);
+    if (!isConfirmed(confirmation)) {
+        return confirmation;
+    }
+    const cameraRebootData = await rebootCameras(cameraUuids, extra._meta?.requestModifiers, extra.sessionId);
+    if (!cameraRebootData) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: "Failed to reboot cameras",
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(cameraRebootData),
+            },
+        ],
+    };
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/tools/report-tool.js

@@ -0,0 +1,190 @@
+import { TOOL_ARGS, OUTPUT_SCHEMA, RequestType, } from "../types/report-tool-types.js";
+import { getOccupancyCountReport, getSummaryCountReport, getOccupancyEnabledCameras, getLineCrossingEnabledCameras, getThresholdCrossingCountReport, findPromptConfigurations, getCustomLLMReport, } from "../api/report-tool-api.js";
+const TOOL_NAME = "report-tool";
+const TOOL_DESCRIPTION = `
+This tool generates summary count reports for various types of data within the Rhombus system.
+It provides aggregated counts over specified time intervals and scopes.
+This tool should be used when users need high level summary reports, analytics, or aggregated counts of system events and activities.
+If types contains PEOPLE please understand that this is not a unique person count, it is a count of people detection events. 
+It's useful for getting a high level count of people, but not for getting a unique person count.
+
+This tool can also retrieve a list of cameras that have occupancy reporting enabled, which is useful as a first step
+before running GET_SUMMARY_COUNT_REPORT since the uuid pulled from summaryCountRequest should always be present on
+the list returned from getOccupancyEnabledCameras.
+
+Additionally, this tool supports line crossing analytics:
+- GET_LINE_CROSSING_ENABLED_CAMERAS: Retrieves cameras at a location that have line crossing enabled, along with their configurations.
+  This should be called first to identify which cameras can be used for threshold crossing reports.
+- GET_THRESHOLD_CROSSING_COUNT_REPORT: Generates reports showing ingress and egress counts for line crossings over time.
+  Automatically calculates key metrics including:
+  • Average entries per hour
+  • Average exits per hour
+  • Hour with most entries (with timestamp and count)
+  • Hour with most exits (with timestamp and count)
+  • Busiest hour overall (total activity with breakdown)
+  Supports human and vehicle crossing detection with configurable time buckets (quarter hour, hour, day, week).
+
+The tool also supports custom user-defined event reporting:
+- FIND_PROMPT_CONFIGURATIONS: Retrieves all custom event prompt configurations. This should be called first to discover
+  what custom events are available for reporting (e.g., "black dog sightings", "delivery truck arrivals", etc.).
+  Each configuration includes the prompt text, UUID, and promptType (COUNT, PERCENT, or BOOLEAN) needed for generating reports.
+- GET_CUSTOM_LLM_REPORT: Generates time series reports for a specific custom event using the prompt UUID.
+  The promptType field from the configuration determines which API endpoint is used:
+  • COUNT: Returns numeric counts (e.g., "3 black dogs detected")
+  • PERCENT: Returns percentage values (e.g., "75% occupancy")
+  • BOOLEAN: Returns true/false values (e.g., "parking lot full: true")
+  Returns aggregated data over specified time intervals (minutely, quarter-hourly, hourly, daily, weekly, monthly).
+  Use this after finding the appropriate prompt configuration to get historical data for custom events.
+`;
+const TOOL_HANDLER = async (args, extra) => {
+    const { requestType } = args;
+    if (requestType === RequestType.GET_SUMMARY_COUNT_REPORT) {
+        const { summaryCountRequest } = args;
+        if (!summaryCountRequest) {
+            throw new Error("summaryCountRequest is required");
+        }
+        const { interval, scope, types, rangeStart, rangeEnd, uuid } = summaryCountRequest;
+        const report = await getSummaryCountReport(interval, scope, types, uuid ?? undefined, new Date(rangeEnd).getTime(), new Date(rangeStart).getTime(), extra._meta?.requestModifiers, extra.sessionId, args.summaryCountRequest.timeZone);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                summaryCountReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.GET_OCCUPANCY_COUNT_REPORT) {
+        const { occupancyCountRequest } = args;
+        if (!occupancyCountRequest) {
+            throw new Error("occupancyCountRequest is required");
+        }
+        const { deviceUuid, rangeStart, rangeEnd, interval } = occupancyCountRequest;
+        const report = await getOccupancyCountReport(deviceUuid, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), interval, extra._meta?.requestModifiers, extra.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                occupancyCountReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.GET_OCCUPANCY_ENABLED_CAMERAS) {
+        const report = await getOccupancyEnabledCameras(extra._meta?.requestModifiers, extra.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                occupancyEnabledCamerasReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.GET_LINE_CROSSING_ENABLED_CAMERAS) {
+        const { lineCrossingEnabledCamerasRequest } = args;
+        if (!lineCrossingEnabledCamerasRequest) {
+            throw new Error("lineCrossingEnabledCamerasRequest is required");
+        }
+        const { locationUuid } = lineCrossingEnabledCamerasRequest;
+        const report = await getLineCrossingEnabledCameras(locationUuid, extra._meta?.requestModifiers, extra.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                lineCrossingEnabledCamerasReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.GET_THRESHOLD_CROSSING_COUNT_REPORT) {
+        const { thresholdCrossingCountRequest } = args;
+        if (!thresholdCrossingCountRequest) {
+            throw new Error("thresholdCrossingCountRequest is required");
+        }
+        const { deviceUuid, rangeStart, rangeEnd, bucketSize, crossingObject, dedupe } = thresholdCrossingCountRequest;
+        const report = await getThresholdCrossingCountReport(deviceUuid, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), bucketSize, crossingObject, dedupe, extra._meta?.requestModifiers, extra.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                thresholdCrossingCountReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.FIND_PROMPT_CONFIGURATIONS) {
+        const report = await findPromptConfigurations(extra._meta?.requestModifiers, extra.sessionId);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                promptConfigurationsReport: report,
+            },
+        };
+    }
+    if (requestType === RequestType.GET_CUSTOM_LLM_REPORT) {
+        const { customLLMReportRequest } = args;
+        if (!customLLMReportRequest) {
+            throw new Error("customLLMReportRequest is required");
+        }
+        const { promptUuid, promptType, rangeStart, rangeEnd, interval } = customLLMReportRequest;
+        const report = await getCustomLLMReport(promptUuid, promptType, new Date(rangeStart).getTime(), new Date(rangeEnd).getTime(), interval, extra._meta?.requestModifiers, extra.sessionId);
+        // Log the report data to help debug
+        console.log("📊 Custom LLM Report Tool Response:", JSON.stringify({
+            promptType,
+            hasError: report?.error,
+            dataPointsCount: report?.timeSeriesDataPoints?.length,
+            firstDataPoint: report?.timeSeriesDataPoints?.[0],
+        }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(report),
+                },
+            ],
+            structuredContent: {
+                customLLMReport: report,
+            },
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: "",
+            },
+        ],
+        structuredContent: {
+            error: true,
+            errorMsg: "Error while fetching report information",
+        },
+    };
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS.shape,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

package/dist/tools/time-conversion-tool.js

@@ -0,0 +1,43 @@
+import { TOOL_ARGS } from "../types/time-conversion-tool-types.js";
+const TOOL_NAME = "time-conversion-tool";
+const TOOL_DESCRIPTION = "This tool is capable of converting to and from epoch and ISO 8601 timestamps. Use this tool when you have one time format and need to convert to the other format. The tool will automatically detect the input format and convert to the other format.";
+const TOOL_HANDLER = async (args, extra) => {
+    const { time_to_convert } = args;
+    if (typeof time_to_convert === "string") {
+        // Input is ISO 8601, convert to epoch
+        const date = new Date(time_to_convert);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ epoch: date.getTime() }),
+                },
+            ],
+        };
+    }
+    else if (typeof time_to_convert === "number") {
+        // Input is epoch, convert to ISO 8601
+        const date = new Date(time_to_convert);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ iso: date.toISOString() }),
+                },
+            ],
+        };
+    }
+    else {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({ error: "Invalid input type for time_to_convert" }),
+                },
+            ],
+        };
+    }
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/tools/time-tool.js

@@ -1,59 +1,19 @@
-import { parse } from "chrono-node";
-import { DateTime } from "luxon";
-import { z } from "zod";
-import { logger } from "../logger.js";
-function nullToUndefined(value) {
-    return value === null ? undefined : value;
-}
+import { parseTimeDescription } from "../api/time-tool-api.js";
+import { TOOL_ARGS } from "../types/time-tool-types.js";
+const TOOL_NAME = "time-tool";
+const TOOL_DESCRIPTION = "This tool is capable of returning the time from a natural language query.  If the user asks about the 'current time' use this tool.  Try to kee time_description as close to the users initial query as possible.  For example if someone says 'was X person seen today?' then time_description should be 'today'.";
+const TOOL_HANDLER = async (args, extra) => {
+    const { time_description, timezone } = args;
+    const result = parseTimeDescription(time_description ?? undefined, timezone ?? undefined, extra);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+        ],
+    };
+};
 export function createTool(server) {
-    server.tool("time-tool", "Tool for converting a natural language time description into a timestamp in milliseconds.", {
-        time_description: z
-            .string()
-            .describe("A natural language description of the time (e.g., '2pm today', 'tomorrow at noon')."),
-        timezone: z
-            .string()
-            .optional()
-            .describe("Optional IANA timezone string (e.g., 'America/Los_Angeles', 'UTC'). Will default to system timezone if not provided."),
-    }, async ({ time_description, timezone }, extra) => {
-        logger.info("EXTRA", extra);
-        // console.error(`🕛 handling tool call for time ${time_description} using timezone ${timezone}`);
-        const now = DateTime.now()
-            .setZone(timezone || undefined)
-            .toJSDate();
-        const parsed = parse(time_description, now, { forwardDate: true });
-        if (!parsed || parsed.length === 0) {
-            throw new Error(`Could not parse time description: ${time_description}`);
-        }
-        const dateComponents = parsed[0].start;
-        if (!dateComponents) {
-            throw new Error("Parsed time has no start component");
-        }
-        const dt = DateTime.fromObject({
-            year: nullToUndefined(dateComponents.get("year")),
-            month: nullToUndefined(dateComponents.get("month")),
-            day: nullToUndefined(dateComponents.get("day")),
-            hour: nullToUndefined(dateComponents.get("hour")),
-            minute: nullToUndefined(dateComponents.get("minute")),
-            second: nullToUndefined(dateComponents.get("second")),
-            millisecond: 0,
-        }, {
-            zone: timezone || "local",
-        });
-        if (!dt.isValid) {
-            throw new Error(`Could not construct valid DateTime: ${dt.invalidReason}`);
-        }
-        const timestamp = dt.toMillis();
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: JSON.stringify({
-                        timestamp,
-                        iso: dt.toISO(),
-                        timezone: dt.zoneName,
-                    }),
-                },
-            ],
-        };
-    });
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
 }