rhombus-node-mcp 0.1.15 → 0.1.17

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

@@ -0,0 +1,426 @@
+import { getLogger } from "../logger.js";
+import { postApi } from "../network.js";
+import { formatTimestamp } from "../util.js";
+import { GetCountReportV2WSRequestTypesEnum } from "../types/schema-components.js";
+import { DateTime } from "luxon";
+const REPORT_TYPES_THAT_RETURN_UTC = new Set([
+    GetCountReportV2WSRequestTypesEnum.BANDWIDTH,
+    GetCountReportV2WSRequestTypesEnum.VEHICLES,
+    GetCountReportV2WSRequestTypesEnum.MOTION,
+    GetCountReportV2WSRequestTypesEnum.DWELL,
+]);
+const logger = getLogger();
+function getUtcTime(datetime, reportType, timeZone) {
+    if (REPORT_TYPES_THAT_RETURN_UTC.has(reportType)) {
+        return datetime;
+    }
+    else {
+        logger.info("timeZone", datetime);
+        return DateTime.fromISO(datetime, { zone: timeZone }).toUTC().toISO();
+    }
+}
+export async function getOccupancyCountReport(deviceUuid, startTimeMs, endTimeMs, interval, requestModifiers, sessionId) {
+    const body = {
+        deviceUuid,
+        startTimeMs,
+        endTimeMs,
+        interval,
+    };
+    const response = await postApi({
+        route: "/report/getOccupancyCounts",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    response.timeSeriesDataPoints = (response.timeSeriesDataPoints || []).map(dataPoint => {
+        const dateLocalMs = new Date(dataPoint.dateLocal || "").getTime();
+        const dateUtcMs = new Date(dataPoint.dateUtc || "").getTime();
+        logger.info("timeSeriesDataPoints dataPoint:", JSON.stringify(dataPoint));
+        return {
+            ...dataPoint,
+            dateLocalString: formatTimestamp(dateLocalMs),
+            dateUtcString: formatTimestamp(dateUtcMs),
+        };
+    });
+    return response;
+}
+export async function getSummaryCountReport(interval, scope, types, uuid, endTimeMs, startTimeMs, requestModifiers, sessionId, timeZone) {
+    logger.info("📊 Getting summary count report", JSON.stringify({
+        interval,
+        scope,
+        types,
+        endTimeMs,
+        startTimeMs,
+        uuid,
+    }));
+    const body = {
+        endTimeMs,
+        interval,
+        scope,
+        startTimeMs,
+        types,
+        ...(uuid ? { uuid } : {}),
+    };
+    const response = await postApi({
+        route: "/report/getCountReportV2",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    // Process response to convert date strings to UTC milliseconds timestamps
+    let newTimeSeriesDataPoints = undefined;
+    if (response && response.timeSeriesDataPoints && Array.isArray(response.timeSeriesDataPoints)) {
+        newTimeSeriesDataPoints = response.timeSeriesDataPoints.map((dataPoint) => {
+            const sanitizedDataPoint = {
+                eventCountMap: dataPoint.eventCountMap,
+                dateUtcString: getUtcTime(dataPoint.dateLocal, dataPoint.type, timeZone),
+            };
+            return sanitizedDataPoint;
+        });
+    }
+    return {
+        error: response.error,
+        errorMsg: response.errorMsg ?? undefined,
+        timeSeriesDataPoints: newTimeSeriesDataPoints,
+    };
+}
+export async function getOccupancyEnabledCameras(requestModifiers, sessionId) {
+    logger.info("📷 Getting occupancy enabled cameras");
+    const body = {};
+    const response = await postApi({
+        route: "/camera/getOccupancyEnabledCameras",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    // Transform the response to handle null values
+    const cameras = response.cameras
+        ? response.cameras.map(camera => ({
+            uuid: camera.uuid ?? undefined,
+            deviceUuid: camera.deviceUuid ?? undefined,
+            name: camera.name ?? undefined,
+            serialNumber: camera.serialNumber ?? undefined,
+            locationUuid: camera.locationUuid ?? undefined,
+            facetNameMap: camera.facetNameMap ?? undefined,
+            deleted: camera.deleted ?? undefined,
+            pending: camera.pending ?? undefined,
+            mummified: camera.mummified ?? undefined,
+        }))
+        : undefined;
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        cameras,
+    };
+}
+export async function getLineCrossingEnabledCameras(locationUuid, requestModifiers, sessionId) {
+    logger.info("🚶 Getting line crossing enabled cameras for location", locationUuid);
+    const body = {
+        locationUuid,
+    };
+    const response = await postApi({
+        route: "/camera/getLineCrossingEnabledCamerasForLocation",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        camerasToConfigs: response.camerasToConfigs ?? undefined,
+    };
+}
+export async function getThresholdCrossingCountReport(deviceUuid, startTimeMs, endTimeMs, bucketSize, crossingObject, dedupe, requestModifiers, sessionId) {
+    logger.info("🚪 Getting threshold crossing count report", JSON.stringify({
+        deviceUuid,
+        startTimeMs,
+        endTimeMs,
+        bucketSize,
+        crossingObject,
+        dedupe,
+    }));
+    const body = {
+        deviceUuid,
+        startTimeMs,
+        endTimeMs,
+        bucketSize,
+        crossingObject,
+        dedupe,
+    };
+    const response = await postApi({
+        route: "/report/getThresholdCrossingCountReport",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    // Transform the response to handle null values
+    const crossingCounts = response.crossingCounts
+        ? response.crossingCounts.map(count => ({
+            timestampMs: count.timestampMs ?? undefined,
+            ingressCount: count.ingressCount ?? undefined,
+            egressCount: count.egressCount ?? undefined,
+        }))
+        : undefined;
+    // Calculate metrics if we have crossing counts and the bucket size is appropriate
+    let metrics = undefined;
+    if (crossingCounts && crossingCounts.length > 0) {
+        // Calculate total entries and exits
+        let totalEntries = 0;
+        let totalExits = 0;
+        let maxEntries = 0;
+        let maxExits = 0;
+        let maxTotal = 0;
+        let maxEntriesTimestamp;
+        let maxExitsTimestamp;
+        let maxTotalTimestamp;
+        let maxTotalEntries = 0;
+        let maxTotalExits = 0;
+        crossingCounts.forEach(count => {
+            const entries = count.ingressCount || 0;
+            const exits = count.egressCount || 0;
+            const total = entries + exits;
+            totalEntries += entries;
+            totalExits += exits;
+            // Track max entries
+            if (entries > maxEntries) {
+                maxEntries = entries;
+                maxEntriesTimestamp = count.timestampMs;
+            }
+            // Track max exits
+            if (exits > maxExits) {
+                maxExits = exits;
+                maxExitsTimestamp = count.timestampMs;
+            }
+            // Track busiest hour (max total)
+            if (total > maxTotal) {
+                maxTotal = total;
+                maxTotalTimestamp = count.timestampMs;
+                maxTotalEntries = entries;
+                maxTotalExits = exits;
+            }
+        });
+        // Calculate hours based on bucket size
+        let hoursInPeriod = 1;
+        const periodMs = endTimeMs - startTimeMs;
+        if (bucketSize === "HOUR") {
+            hoursInPeriod = periodMs / (1000 * 60 * 60);
+        }
+        else if (bucketSize === "QUARTER_HOUR") {
+            // For quarter hour buckets, we need to aggregate to hourly
+            hoursInPeriod = periodMs / (1000 * 60 * 60);
+            // Note: For more accurate hourly calculations with quarter-hour buckets,
+            // we'd need to group by hour, but for now we'll use the total period
+        }
+        else if (bucketSize === "DAY") {
+            hoursInPeriod = periodMs / (1000 * 60 * 60);
+        }
+        else if (bucketSize === "WEEK") {
+            hoursInPeriod = periodMs / (1000 * 60 * 60);
+        }
+        // Helper function to format hour labels
+        const formatHourLabel = (timestampMs) => {
+            if (!timestampMs)
+                return "Unknown";
+            const date = DateTime.fromMillis(timestampMs);
+            if (bucketSize === "HOUR") {
+                const endHour = date.plus({ hours: 1 });
+                return `${date.toFormat("h:mm a")} - ${endHour.toFormat("h:mm a")} (${date.toFormat("MMM d, yyyy")})`;
+            }
+            else if (bucketSize === "QUARTER_HOUR") {
+                const endTime = date.plus({ minutes: 15 });
+                return `${date.toFormat("h:mm a")} - ${endTime.toFormat("h:mm a")} (${date.toFormat("MMM d, yyyy")})`;
+            }
+            else if (bucketSize === "DAY") {
+                return date.toFormat("MMM d, yyyy");
+            }
+            else if (bucketSize === "WEEK") {
+                const endWeek = date.plus({ weeks: 1 }).minus({ days: 1 });
+                return `Week of ${date.toFormat("MMM d")} - ${endWeek.toFormat("MMM d, yyyy")}`;
+            }
+            return date.toISO() || "Unknown";
+        };
+        metrics = {
+            averageEntriesPerHour: totalEntries / hoursInPeriod,
+            averageExitsPerHour: totalExits / hoursInPeriod,
+            mostEntriesInHour: {
+                count: maxEntries,
+                timestamp: maxEntriesTimestamp ? DateTime.fromMillis(maxEntriesTimestamp).toISO() : "",
+                hourLabel: formatHourLabel(maxEntriesTimestamp),
+            },
+            mostExitsInHour: {
+                count: maxExits,
+                timestamp: maxExitsTimestamp ? DateTime.fromMillis(maxExitsTimestamp).toISO() : "",
+                hourLabel: formatHourLabel(maxExitsTimestamp),
+            },
+            busiestHour: {
+                totalCount: maxTotal,
+                timestamp: maxTotalTimestamp ? DateTime.fromMillis(maxTotalTimestamp).toISO() : "",
+                hourLabel: formatHourLabel(maxTotalTimestamp),
+                entries: maxTotalEntries,
+                exits: maxTotalExits,
+            },
+        };
+    }
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        crossingCounts,
+        metrics,
+    };
+}
+export async function findPromptConfigurations(requestModifiers, sessionId) {
+    logger.info("🔍 Finding custom event prompt configurations");
+    const body = {};
+    const response = await postApi({
+        route: "/scenequery/findPromptConfigurations",
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    // Transform the response to handle null values
+    const promptConfigurations = response.promptConfigurations
+        ? response.promptConfigurations.map(config => ({
+            active: config.active ?? undefined,
+            cameraConfigurations: config.cameraConfigurations ?? undefined,
+            checkCondition: config.checkCondition ?? undefined,
+            description: config.description ?? undefined,
+            name: config.name ?? undefined,
+            orgUuid: config.orgUuid ?? undefined,
+            prompt: config.prompt ?? undefined,
+            promptType: config.promptType ?? undefined,
+            scheduleUuid: config.scheduleUuid ?? undefined,
+            shortName: config.shortName ?? undefined,
+            uuid: config.uuid ?? undefined,
+        }))
+        : undefined;
+    return {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        promptConfigurations,
+    };
+}
+export async function getCustomLLMReport(promptUuid, promptType, startTimeMs, endTimeMs, interval, requestModifiers, sessionId) {
+    logger.info("📊 Getting custom LLM report", JSON.stringify({
+        promptUuid,
+        promptType,
+        startTimeMs,
+        endTimeMs,
+        interval,
+    }));
+    const body = {
+        promptUuid,
+        startTimeMs,
+        endTimeMs,
+        interval,
+    };
+    // Determine the correct endpoint based on promptType
+    let route;
+    switch (promptType) {
+        case "COUNT":
+            route = "/report/getCustomLLMNumericCounts";
+            break;
+        case "PERCENT":
+            route = "/report/getCustomLLMReport";
+            break;
+        case "BOOLEAN":
+            route = "/report/getCustomLLMBinaryCounts";
+            break;
+        default:
+            throw new Error(`Unknown prompt type: ${promptType}`);
+    }
+    const response = await postApi({
+        route,
+        body,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    logger.info("📊 Custom LLM API response:", JSON.stringify({
+        promptType,
+        hasReports: !!response.reports,
+        hasTimeSeriesDataPoints: !!response.timeSeriesDataPoints,
+        error: response.error,
+    }));
+    // Different prompt types return different response structures
+    let timeSeriesDataPoints;
+    if ((promptType === "BOOLEAN" || promptType === "PERCENT") && response.reports) {
+        // BOOLEAN and PERCENT types return a reports object with device UUIDs as keys
+        const reportEntries = Object.entries(response.reports);
+        logger.info(`📊 ${promptType} response structure:`, JSON.stringify({ reportEntries: reportEntries.length }));
+        // Aggregate data from all devices
+        const aggregatedData = {};
+        reportEntries.forEach(([deviceId, reportData]) => {
+            if (Array.isArray(reportData)) {
+                reportData.forEach((item) => {
+                    const dateKey = item.localDate || new Date().toISOString();
+                    if (!aggregatedData[dateKey]) {
+                        aggregatedData[dateKey] = {
+                            dateLocal: item.localDate,
+                            eventCount: 0,
+                            true: 0,
+                            false: 0,
+                            // For PERCENT type, store percentage values
+                            percentages: {},
+                        };
+                    }
+                    if (promptType === "BOOLEAN") {
+                        aggregatedData[dateKey].eventCount += item.eventCount || 0;
+                        aggregatedData[dateKey].true += item.true || 0;
+                        aggregatedData[dateKey].false += item.false || 0;
+                    }
+                    else if (promptType === "PERCENT") {
+                        // For PERCENT type, aggregate percentage data
+                        aggregatedData[dateKey].eventCount += item.eventCount || 0;
+                        // Store any percentage-related fields from the response
+                        Object.entries(item).forEach(([key, value]) => {
+                            if (key !== "localDate" && key !== "eventCount") {
+                                // Store any numeric values as percentages (could be number or string percentage)
+                                aggregatedData[dateKey].percentages[key] = value;
+                            }
+                        });
+                    }
+                });
+            }
+        });
+        // Convert aggregated data to timeSeriesDataPoints format
+        timeSeriesDataPoints = Object.entries(aggregatedData).map(([date, data]) => ({
+            dateLocal: data.dateLocal ?? undefined,
+            dateUtc: data.dateLocal ?? undefined, // Convert to UTC if needed
+            eventCountMap: promptType === "BOOLEAN"
+                ? {
+                    total: data.eventCount,
+                    true: data.true,
+                    false: data.false,
+                }
+                : {
+                    total: data.eventCount,
+                    ...data.percentages,
+                },
+        }));
+    }
+    else if (response.timeSeriesDataPoints) {
+        // COUNT type uses the standard timeSeriesDataPoints format
+        timeSeriesDataPoints = response.timeSeriesDataPoints.map((dataPoint) => ({
+            dateLocal: dataPoint.dateLocal ?? undefined,
+            dateUtc: dataPoint.dateUtc ?? undefined,
+            eventCountMap: dataPoint.eventCountMap
+                ? Object.entries(dataPoint.eventCountMap).reduce((acc, [key, value]) => {
+                    if (value !== null && value !== undefined) {
+                        acc[key] = value;
+                    }
+                    return acc;
+                }, {})
+                : undefined,
+        }));
+    }
+    const result = {
+        error: response.error ?? undefined,
+        errorMsg: response.errorMsg ?? undefined,
+        timeSeriesDataPoints,
+    };
+    logger.info("📊 Custom LLM report result:", JSON.stringify({
+        hasError: !!result.error,
+        dataPointsCount: timeSeriesDataPoints?.length ?? 0,
+        firstDataPoint: timeSeriesDataPoints?.[0],
+    }));
+    return result;
+}

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

@@ -0,0 +1,90 @@
+import { parse } from "chrono-node";
+import { DateTime } from "luxon";
+import { logger } from "../logger.js";
+export function nullToUndefined(value) {
+    return value === null ? undefined : value;
+}
+function normalizeTimeDescription(description) {
+    const normalized = description.toLowerCase().trim();
+    if (normalized.includes("current time")) {
+        return "now";
+    }
+    // Handle plain day references as start of day
+    if (normalized === "today") {
+        return "today at 00:00";
+    }
+    if (normalized === "yesterday") {
+        return "yesterday at 00:00";
+    }
+    if (normalized === "tomorrow") {
+        return "tomorrow at 00:00";
+    }
+    // Handle "this" time periods - always refer to today
+    if (normalized === "this morning") {
+        return "today at 06:00";
+    }
+    if (normalized === "this afternoon") {
+        return "today at 12:00";
+    }
+    if (normalized === "this evening") {
+        return "today at 18:00";
+    }
+    if (normalized === "this night" || normalized === "tonight") {
+        return "today at 20:00";
+    }
+    if (normalized.includes("start of today") || normalized.includes("beginning of today")) {
+        return "today at 00:00";
+    }
+    if (normalized.includes("start of yesterday") || normalized.includes("beginning of yesterday")) {
+        return "yesterday at 00:00";
+    }
+    if (normalized.includes("start of tomorrow") || normalized.includes("beginning of tomorrow")) {
+        return "tomorrow at 00:00";
+    }
+    if (normalized.includes("end of today")) {
+        return "today at 23:59:59";
+    }
+    if (normalized.includes("end of yesterday")) {
+        return "yesterday at 23:59:59";
+    }
+    if (normalized.includes("end of tomorrow")) {
+        return "tomorrow at 23:59:59";
+    }
+    return description;
+}
+export function parseTimeDescription(time_description, timezone, extra) {
+    logger.info("EXTRA", extra);
+    const now = new Date(DateTime.now().setZone(timezone || "America/Los_Angeles").toISO({ includeOffset: false }));
+    const normalizedDescription = normalizeTimeDescription(time_description);
+    logger.info(`TIME TOOL ${timezone}: Normalized "${time_description}" to "${normalizedDescription}"`);
+    // Use the timezone-adjusted date as the reference date for chrono-node
+    const parsed = parse(normalizedDescription, now);
+    if (!parsed || parsed.length === 0) {
+        throw new Error(`Could not parse time description: ${time_description}`);
+    }
+    logger.info(`TIME TOOLPARSED ${time_description}`, JSON.stringify(parsed));
+    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 {
+        timestamp,
+        iso: dt.toISO(),
+        timezone: dt.zoneName,
+    };
+}

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

@@ -0,0 +1,148 @@
+import { postApi } from "../network.js";
+/**
+ * Updates camera configuration using the faceted config API
+ */
+export async function updateCameraConfig(payload, requestModifiers, sessionId) {
+    try {
+        const result = await postApi({
+            route: "/camera/updateFacetedConfig",
+            body: payload,
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        if (result.error) {
+            return {
+                success: false,
+                error: result.errorMsg || "Failed to update camera configuration",
+            };
+        }
+        return {
+            success: true,
+            updatedSettings: payload.configUpdate,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+/**
+ * Gets current camera configuration
+ */
+export async function getCameraDetails(cameraUuid, requestModifiers, sessionId) {
+    try {
+        const result = await postApi({
+            route: "/camera/getDetailsV2",
+            body: {
+                uuid: cameraUuid,
+            },
+            modifiers: requestModifiers,
+            sessionId,
+        });
+        if (result.error) {
+            return {
+                success: false,
+                error: result.errorMsg || "Failed to get camera details",
+            };
+        }
+        return {
+            success: true,
+            data: result.camera,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : "Unknown error occurred",
+        };
+    }
+}
+/**
+ * Helper function to remove null/undefined fields from update payload
+ */
+export function cleanUpdatePayload(payload) {
+    const cleaned = {};
+    for (const [key, value] of Object.entries(payload)) {
+        if (value !== null && value !== undefined) {
+            if (typeof value === "object" && !Array.isArray(value)) {
+                const cleanedValue = cleanUpdatePayload(value);
+                if (Object.keys(cleanedValue).length > 0) {
+                    cleaned[key] = cleanedValue;
+                }
+            }
+            else {
+                cleaned[key] = value;
+            }
+        }
+    }
+    return cleaned;
+}
+/**
+ * Formats camera settings for display
+ */
+export function formatCameraSettings(settings) {
+    const sections = [];
+    if (settings.videoFacetSettings) {
+        const videoSettings = Object.values(settings.videoFacetSettings)[0];
+        if (videoSettings) {
+            const videoItems = [];
+            if (videoSettings.resolution)
+                videoItems.push(`Resolution: ${videoSettings.resolution.width}x${videoSettings.resolution.height}`);
+            if (videoSettings.img_brightness !== undefined)
+                videoItems.push(`Brightness: ${videoSettings.img_brightness}`);
+            if (videoSettings.img_contrast !== undefined)
+                videoItems.push(`Contrast: ${videoSettings.img_contrast}`);
+            if (videoSettings.img_saturation !== undefined)
+                videoItems.push(`Saturation: ${videoSettings.img_saturation}`);
+            if (videoSettings.img_sharpness !== undefined)
+                videoItems.push(`Sharpness: ${videoSettings.img_sharpness}`);
+            if (videoSettings.hdr_enabled !== undefined)
+                videoItems.push(`HDR: ${videoSettings.hdr_enabled ? "On" : "Off"}`);
+            if (videoSettings.wdr_enabled !== undefined)
+                videoItems.push(`WDR: ${videoSettings.wdr_enabled ? "On" : "Off"}`);
+            if (videoSettings.wdr_strength !== undefined)
+                videoItems.push(`WDR Strength: ${videoSettings.wdr_strength}`);
+            if (videoSettings.video_persist_disabled !== undefined)
+                videoItems.push(`Video Persist: ${videoSettings.video_persist_disabled ? "Disabled" : "Enabled"}`);
+            if (videoSettings.zero_motion_video_bitrate_percent !== undefined)
+                videoItems.push(`Zero Motion Bitrate: ${videoSettings.zero_motion_video_bitrate_percent}%`);
+            if (videoItems.length > 0) {
+                sections.push("**Video Settings:**\n" + videoItems.map(item => `• ${item}`).join("\n"));
+            }
+        }
+    }
+    if (settings.audioFacetSettings) {
+        const audioSettings = Object.values(settings.audioFacetSettings)[0];
+        if (audioSettings) {
+            const audioItems = [];
+            if (audioSettings.audio_record !== undefined)
+                audioItems.push(`Recording: ${audioSettings.audio_record ? "On" : "Off"}`);
+            if (audioSettings.device_mic_enabled !== undefined)
+                audioItems.push(`Microphone: ${audioSettings.device_mic_enabled ? "Enabled" : "Disabled"}`);
+            if (audioSettings.device_speaker_enabled !== undefined)
+                audioItems.push(`Speaker: ${audioSettings.device_speaker_enabled ? "Enabled" : "Disabled"}`);
+            if (audioItems.length > 0) {
+                sections.push("**Audio Settings:**\n" + audioItems.map(item => `• ${item}`).join("\n"));
+            }
+        }
+    }
+    if (settings.deviceSettings) {
+        const deviceItems = [];
+        if (settings.deviceSettings.camera_name)
+            deviceItems.push(`Name: ${settings.deviceSettings.camera_name}`);
+        if (settings.deviceSettings.camera_timezone)
+            deviceItems.push(`Timezone: ${settings.deviceSettings.camera_timezone}`);
+        if (settings.deviceSettings.led_mode)
+            deviceItems.push(`LED Mode: ${settings.deviceSettings.led_mode}`);
+        if (settings.deviceSettings.led_intensity !== undefined)
+            deviceItems.push(`LED Intensity: ${settings.deviceSettings.led_intensity}`);
+        if (settings.deviceSettings.led_stealth_mode !== undefined)
+            deviceItems.push(`LED Stealth Mode: ${settings.deviceSettings.led_stealth_mode ? "On" : "Off"}`);
+        if (deviceItems.length > 0) {
+            sections.push("**Device Settings:**\n" + deviceItems.map(item => `• ${item}`).join("\n"));
+        }
+    }
+    return sections.join("\n\n");
+}

package/dist/createServer.js

@@ -36,7 +36,13 @@ export default async function createServer() {
     }
     logger.info(`🛠️ Registered ${resources.length} resources`);
     for (const tool of tools) {
-        tool.create(server);
+        try {
+            await tool.create(server);
+        }
+        catch (error) {
+            logger.error(`Failed to register tool ${tool.name}:`, error);
+            // Continue with other tools instead of failing completely
+        }
     }
     logger.info(`🛠️ Registered ${tools.length} tools`);
     logger.info(`✅ Server created`);