rhombus-node-mcp 0.1.55 → 0.1.57

package/dist/tools-console/update-tool.js

@@ -1,48 +1,84 @@
-import { updateCameraConfig, getCameraDetails, cleanUpdatePayload, formatCameraSettings, validateCameraFeatureSupport, } from "../api/update-tool-api.js";
+import { updateCameraConfig, getCameraDetails, cleanUpdatePayload, formatCameraSettings, validateCameraFeatureSupport, updateDoorbellCameraConfig, getDoorbellCameraDetails, getDoorbellCameraConfig, } from "../api/update-tool-api.js";
 import { OUTPUT_SCHEMA, TOOL_ARGS, UpdateCameraConfigPayload, CameraVideoSettings, CameraAudioSettings, CameraDeviceSettings, parseFacetedUuid, } from "../types/update-tool-types.js";
 import { logger } from "../logger.js";
 const TOOL_NAME = "update-tool";
 const TOOL_DESCRIPTION = `
-This tool allows updating configuration settings for various Rhombus entities. Currently supports:
-- **Cameras**: Update video settings (resolution, HDR, WDR, brightness, contrast, etc.), audio settings (recording, microphone, speaker), and device settings (name, timezone, LED control).
+Updates configuration settings for Rhombus cameras and doorbell cameras: video settings (resolution, HDR/WDR, brightness, contrast, saturation), audio settings (recording, microphone, speaker) and device settings (name, timezone, LED control). Use this tool for ALL camera settings changes, including image-quality fixes (too dark, washed out, blurry).
 
-For LED control, use EXACTLY these field names in cameraDeviceSettings:
-- To turn LED off: {"led_stealth_mode": true} (recommended) or {"led_mode": "always_off"}
-- To turn LED on: {"led_stealth_mode": false} or {"led_mode": "always_on"} or {"led_mode": "auto"}
-- IMPORTANT: Use underscore in field names (led_mode, led_stealth_mode), not camelCase
+MANDATORY confirmation flow: when you have proposed camera-settings fixes and the user replies with any affirmative ("yes", "confirm", "apply", "go ahead", ...), do not send text first — IMMEDIATELY call this tool with the settings you identified, and only report success after it returns. NEVER claim settings were updated without calling it; one confirmation covers all proposed changes.
 
-The tool supports faceted UUIDs (e.g., "cameraUuid.v0" or "cameraUuid.v1") to update specific camera facets. If no facet is specified, defaults to "v0".
-
-The tool guides users through a multi-step process:
-1. Entity selection (if not provided)
-2. Settings configuration with current values shown
-3. Confirmation and application of changes
-
-Future support planned for:
-- Climate sensors
-- Door controllers
-- Environmental gateways
-- Audio gateways
-- Doorbell cameras
-- Badge readers
-
-The tool uses elicitation forms for rich user interaction and shows current settings before updates.
-
----
-
-**CAMERA SETTINGS UPDATE FLOW** — Use this tool for ALL camera settings updates (brightness, contrast, WDR, resolution, audio, LED, etc.).
-- For camera image-quality fixes: provide entityType="camera", entityUuid, and the specific settings to change in cameraVideoSettings.
-- Example for dark image: update-tool(entityType="camera", entityUuid="<uuid>", cameraVideoSettings='{"img_brightness": 0, "wdr_strength": 64}').
-- Example for washed out: update-tool(entityType="camera", entityUuid="<uuid>", cameraVideoSettings='{"img_brightness": -50, "img_contrast": 80}').
-- Saturation matters — saturation 0 yields a grayscale image. Most cameras look best with mid-range values; tune from there.
-
-**CONFIRMATION FLOW (MANDATORY)** — When the conversation history shows you analyzed a camera and proposed fixes, and the user replies with any affirmative ("yes", "confirm", "fix it", "apply", "do it", "go ahead", "proceed", "sure", "ok"):
-1. DO NOT generate any text response first.
-2. IMMEDIATELY call update-tool with the camera settings you previously identified.
-3. Only after update-tool returns successfully, say "Done! Check your camera now…".
-
-NEVER respond saying settings were updated without first calling update-tool — without the call, no changes take effect. Avoid multiple rounds of confirmation; get one confirmation for all proposed changes.
+Exact field names, LED rules, example payloads and faceted-UUID handling are documented on the parameters. The tool shows current settings before applying updates.
 `;
+// EVERY result from this tool must carry structuredContent: the tool registers
+// an outputSchema, and the MCP SDK rejects any non-isError result without
+// structuredContent as "MCP error -32602: ... no structured content was
+// provided" — which REPLACES the real failure text. That is how an out-of-range
+// img_sharpness once reached the user as "a system error" with nothing for the
+// model to correct, so it retried the identical bad value and gave up.
+function errorResult(text) {
+    return {
+        isError: true,
+        content: [{ type: "text", text }],
+        structuredContent: { needUserInput: false, success: false, message: text },
+    };
+}
+// Slice a doorbell camera's flat config down to the fields this tool can set
+// (the keys of one of the three camera settings schemas). The full config has
+// ~150 internal fields — showing all of them would bury the settable ones.
+function pickDoorbellSettings(config, settingsSchema) {
+    const out = {};
+    for (const key of Object.keys(settingsSchema.shape)) {
+        const value = config[key];
+        if (value !== undefined && value !== null)
+            out[key] = value;
+    }
+    return out;
+}
+function valueAtPath(root, path) {
+    return path.reduce((node, key) => node && typeof node === "object" ? node[key] : undefined, root);
+}
+// The settings blocks are free-form JSON strings, so an out-of-range value is
+// the normal failure here, not an exotic one. The message MUST name the field,
+// the bound, and what was received — otherwise the model has nothing to act on.
+function describeSettingsIssues(label, error, input) {
+    const details = error.issues.map(issue => {
+        const field = issue.path.length ? issue.path.join(".") : label;
+        const received = valueAtPath(input, issue.path);
+        const suffix = received === undefined ? "" : ` (received ${JSON.stringify(received)})`;
+        if (issue.code === "too_big") {
+            return `${field} must be at most ${issue.maximum}${suffix}`;
+        }
+        if (issue.code === "too_small") {
+            return `${field} must be at least ${issue.minimum}${suffix}`;
+        }
+        return `${field}: ${issue.message}${suffix}`;
+    });
+    return `Invalid ${label}: ${details.join("; ")}. Check the allowed ranges documented on this tool's parameters, then call again with in-range values. No settings were changed.`;
+}
+function parseSettingsBlock(label, raw, schema, normalize) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            message: `Invalid ${label}: not valid JSON (${error instanceof Error ? error.message : "parse error"}). Pass a JSON object string, e.g. '{"img_brightness": 0}'. No settings were changed.`,
+        };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            ok: false,
+            message: `Invalid ${label}: expected a JSON object, received ${Array.isArray(parsed) ? "an array" : String(parsed === null ? "null" : typeof parsed)}. No settings were changed.`,
+        };
+    }
+    normalize?.(parsed);
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+        return { ok: false, message: describeSettingsIssues(label, result.error, parsed) };
+    }
+    return { ok: true, value: result.data };
+}
 const TOOL_HANDLER = async (args, extra) => {
     const { entityType, entityUuid, cameraVideoSettings, cameraAudioSettings, cameraDeviceSettings, step, } = args;
     // Handle camera updates
@@ -62,41 +98,45 @@ const TOOL_HANDLER = async (args, extra) => {
                 };
                 // Parse and add video settings
                 if (cameraVideoSettings && cameraVideoSettings.trim()) {
-                    const videoSettings = JSON.parse(cameraVideoSettings);
-                    // Validate with zod schema
-                    const validatedVideo = CameraVideoSettings.parse(videoSettings);
+                    const video = parseSettingsBlock("camera video settings", cameraVideoSettings, CameraVideoSettings);
+                    if (!video.ok) {
+                        return errorResult(video.message);
+                    }
                     updatePayload.configUpdate.videoFacetSettings = {
-                        [facet]: cleanUpdatePayload(validatedVideo),
+                        [facet]: cleanUpdatePayload(video.value),
                     };
                 }
                 // Parse and add audio settings
                 if (cameraAudioSettings && cameraAudioSettings.trim()) {
-                    const audioSettings = JSON.parse(cameraAudioSettings);
-                    // Validate with zod schema
-                    const validatedAudio = CameraAudioSettings.parse(audioSettings);
+                    const audio = parseSettingsBlock("camera audio settings", cameraAudioSettings, CameraAudioSettings);
+                    if (!audio.ok) {
+                        return errorResult(audio.message);
+                    }
                     updatePayload.configUpdate.audioFacetSettings = {
-                        [facet]: cleanUpdatePayload(validatedAudio),
+                        [facet]: cleanUpdatePayload(audio.value),
                     };
                 }
                 // Parse and add device settings
                 if (cameraDeviceSettings && cameraDeviceSettings.trim()) {
-                    const deviceSettings = JSON.parse(cameraDeviceSettings);
-                    logger.debug("[update-tool] Raw device settings:", deviceSettings);
-                    // Transform ledMode to led_mode and OFF to always_off before validation
-                    if ("ledMode" in deviceSettings) {
-                        deviceSettings.led_mode =
-                            deviceSettings.ledMode === "OFF" ? "always_off" : deviceSettings.ledMode;
-                        delete deviceSettings.ledMode;
+                    const device = parseSettingsBlock("camera device settings", cameraDeviceSettings, CameraDeviceSettings, deviceSettings => {
+                        logger.debug("[update-tool] Raw device settings:", deviceSettings);
+                        // Transform ledMode to led_mode and OFF to always_off before validation
+                        if ("ledMode" in deviceSettings) {
+                            deviceSettings.led_mode =
+                                deviceSettings.ledMode === "OFF" ? "always_off" : deviceSettings.ledMode;
+                            delete deviceSettings.ledMode;
+                        }
+                        // Convert string "true"/"false" to boolean for led_stealth_mode
+                        if ("led_stealth_mode" in deviceSettings &&
+                            typeof deviceSettings.led_stealth_mode === "string") {
+                            deviceSettings.led_stealth_mode = deviceSettings.led_stealth_mode === "true";
+                        }
+                    });
+                    if (!device.ok) {
+                        return errorResult(device.message);
                     }
-                    // Convert string "true"/"false" to boolean for led_stealth_mode
-                    if ("led_stealth_mode" in deviceSettings &&
-                        typeof deviceSettings.led_stealth_mode === "string") {
-                        deviceSettings.led_stealth_mode = deviceSettings.led_stealth_mode === "true";
-                    }
-                    // Validate with zod schema
-                    const validatedDevice = CameraDeviceSettings.parse(deviceSettings);
-                    logger.debug("[update-tool] Validated device settings:", validatedDevice);
-                    const cleaned = cleanUpdatePayload(validatedDevice);
+                    logger.debug("[update-tool] Validated device settings:", device.value);
+                    const cleaned = cleanUpdatePayload(device.value);
                     logger.debug("[update-tool] Cleaned device settings:", cleaned);
                     updatePayload.configUpdate.deviceSettings = cleaned;
                 }
@@ -104,15 +144,8 @@ const TOOL_HANDLER = async (args, extra) => {
                 const validatedPayload = UpdateCameraConfigPayload.parse(updatePayload);
                 const featureValidation = await validateCameraFeatureSupport(validatedPayload, extra._meta?.requestModifiers, extra.sessionId);
                 if (!featureValidation.canProceed) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: featureValidation.error ||
-                                    "This camera does not support one or more requested features.",
-                            },
-                        ],
-                    };
+                    return errorResult(featureValidation.error ||
+                        "This camera does not support one or more requested features.");
                 }
                 // Apply the updates
                 const result = await updateCameraConfig(validatedPayload, extra._meta?.requestModifiers, extra.sessionId);
@@ -121,14 +154,7 @@ const TOOL_HANDLER = async (args, extra) => {
                     const normalizedError = hasCapabilitySensitiveChange
                         ? "This camera may not support one or more requested settings."
                         : result.error;
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to update camera settings: ${normalizedError}`,
-                            },
-                        ],
-                    };
+                    return errorResult(`Failed to update camera settings: ${normalizedError}`);
                 }
                 // Format the updated settings for display
                 const formattedSettings = formatCameraSettings(validatedPayload.configUpdate);
@@ -151,14 +177,7 @@ const TOOL_HANDLER = async (args, extra) => {
                 };
             }
             catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error updating camera settings: ${error instanceof Error ? error.message : "Unknown error"}`,
-                        },
-                    ],
-                };
+                return errorResult(`Error updating camera settings: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
         // Step 2: Show settings configuration form (if entityUuid provided but no settings)
@@ -169,14 +188,7 @@ const TOOL_HANDLER = async (args, extra) => {
                 // Get current camera details
                 const cameraDetails = await getCameraDetails(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
                 if (!cameraDetails.success || !cameraDetails.data) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to get camera details: ${cameraDetails.error || "Camera not found"}`,
-                            },
-                        ],
-                    };
+                    return errorResult(`Failed to get camera details: ${cameraDetails.error || "Camera not found"}`);
                 }
                 const camera = cameraDetails.data;
                 const currentVideoSettings = camera.videoSettings || {};
@@ -211,14 +223,7 @@ const TOOL_HANDLER = async (args, extra) => {
                 };
             }
             catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Error retrieving camera details: ${error instanceof Error ? error.message : "Unknown error"}`,
-                        },
-                    ],
-                };
+                return errorResult(`Error retrieving camera details: ${error instanceof Error ? error.message : "Unknown error"}`);
             }
         }
         // Step 1: Entity selection (if no entityUuid)
@@ -241,80 +246,205 @@ const TOOL_HANDLER = async (args, extra) => {
             };
         }
     }
-    // Handle other entity types (future implementation)
-    if (entityType === "climate-sensor") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Climate sensor updates are not yet implemented. Coming soon!",
-                },
-            ],
-        };
-    }
-    if (entityType === "door-controller") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Door controller updates are not yet implemented. Coming soon!",
-                },
-            ],
-        };
-    }
-    if (entityType === "environmental-gateway") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Environmental gateway updates are not yet implemented. Coming soon!",
-                },
-            ],
-        };
-    }
-    if (entityType === "audio-gateway") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Audio gateway updates are not yet fully implemented. Coming soon!",
-                },
-            ],
-        };
-    }
+    // Doorbell cameras take the same setting names as cameras, but through
+    // /doorbellcamera/updateConfig with ONE FLAT configUpdate rather than the
+    // faceted video/audio/device split. Validation reuses the camera schemas, so
+    // the documented ranges apply identically.
     if (entityType === "doorbell-camera") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Doorbell camera updates are not yet fully implemented. Coming soon!",
-                },
-            ],
-        };
-    }
-    if (entityType === "badge-reader") {
-        return {
-            content: [
-                {
-                    type: "text",
-                    text: "Badge reader updates are not yet fully implemented. Coming soon!",
-                },
-            ],
-        };
+        if (!entityUuid) {
+            return errorResult("To update a doorbell camera, pass entityUuid plus at least one of cameraVideoSettings, cameraAudioSettings or cameraDeviceSettings. Use get-entity-tool with entityType doorbell-camera to find the uuid.");
+        }
+        const hasDoorbellSettings = Boolean((cameraVideoSettings && cameraVideoSettings.trim()) ||
+            (cameraAudioSettings && cameraAudioSettings.trim()) ||
+            (cameraDeviceSettings && cameraDeviceSettings.trim()));
+        // Step 2 equivalent: uuid but no settings — show the current config so the
+        // model proposes changes against real values rather than guesses. The read
+        // comes from /doorbellcamera/getConfig, which returns the same flat object
+        // the update writes.
+        if (!hasDoorbellSettings) {
+            try {
+                const { baseUuid } = parseFacetedUuid(entityUuid);
+                const details = await getDoorbellCameraDetails(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
+                if (!details.success) {
+                    return errorResult(details.error ?? "Could not verify the doorbell camera.");
+                }
+                const current = await getDoorbellCameraConfig(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
+                if (!current.success || !current.config) {
+                    return errorResult(`Failed to read the doorbell camera's current settings: ${current.error ?? "unknown error"}`);
+                }
+                const jsonResultResponse = {
+                    needUserInput: true,
+                    message: `Configure settings for doorbell camera "${details.name ?? baseUuid}" (${baseUuid})\n\nCurrent settings are shown below. Modify the values you want to change:`,
+                    requestType: "camera-settings-configuration",
+                    submitAction: "update-tool",
+                    entityType: "doorbell-camera",
+                    entityUuid: baseUuid,
+                    currentSettings: {
+                        video: pickDoorbellSettings(current.config, CameraVideoSettings),
+                        audio: pickDoorbellSettings(current.config, CameraAudioSettings),
+                        device: pickDoorbellSettings(current.config, CameraDeviceSettings),
+                    },
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(jsonResultResponse) }],
+                    structuredContent: jsonResultResponse,
+                };
+            }
+            catch (error) {
+                return errorResult(`Error retrieving doorbell camera settings: ${error instanceof Error ? error.message : "Unknown error"}`);
+            }
+        }
+        try {
+            // Doorbell configs are not faceted, so any .v0 suffix is dropped.
+            const { baseUuid } = parseFacetedUuid(entityUuid);
+            const flatSettings = {};
+            if (cameraVideoSettings && cameraVideoSettings.trim()) {
+                const video = parseSettingsBlock("doorbell camera video settings", cameraVideoSettings, CameraVideoSettings);
+                if (!video.ok) {
+                    return errorResult(video.message);
+                }
+                Object.assign(flatSettings, cleanUpdatePayload(video.value));
+            }
+            if (cameraAudioSettings && cameraAudioSettings.trim()) {
+                const audio = parseSettingsBlock("doorbell camera audio settings", cameraAudioSettings, CameraAudioSettings);
+                if (!audio.ok) {
+                    return errorResult(audio.message);
+                }
+                Object.assign(flatSettings, cleanUpdatePayload(audio.value));
+            }
+            if (cameraDeviceSettings && cameraDeviceSettings.trim()) {
+                const device = parseSettingsBlock("doorbell camera device settings", cameraDeviceSettings, CameraDeviceSettings, deviceSettings => {
+                    if ("ledMode" in deviceSettings) {
+                        deviceSettings.led_mode =
+                            deviceSettings.ledMode === "OFF" ? "always_off" : deviceSettings.ledMode;
+                        delete deviceSettings.ledMode;
+                    }
+                    if ("led_stealth_mode" in deviceSettings &&
+                        typeof deviceSettings.led_stealth_mode === "string") {
+                        deviceSettings.led_stealth_mode = deviceSettings.led_stealth_mode === "true";
+                    }
+                });
+                if (!device.ok) {
+                    return errorResult(device.message);
+                }
+                Object.assign(flatSettings, cleanUpdatePayload(device.value));
+            }
+            if (Object.keys(flatSettings).length === 0) {
+                return errorResult("No doorbell camera settings were recognised in the provided values, so nothing was changed.");
+            }
+            // Confirm the device exists first: /doorbellcamera/updateConfig accepts an
+            // unknown uuid without complaining, which would report success for a
+            // change that reached no device.
+            const details = await getDoorbellCameraDetails(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
+            if (!details.success) {
+                return errorResult(details.error ?? "Could not verify the doorbell camera.");
+            }
+            // The update response only echoes the caller's input, so a before/after
+            // read of /doorbellcamera/getConfig is the ONLY way to tell a real write
+            // from a silent no-op. Both reads are best-effort: a failed read skips
+            // verification rather than blocking the write the user asked for.
+            const before = await getDoorbellCameraConfig(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
+            const result = await updateDoorbellCameraConfig(baseUuid, flatSettings, extra._meta?.requestModifiers, extra.sessionId);
+            if (!result.success) {
+                return errorResult(`Failed to update doorbell camera settings: ${result.error}`);
+            }
+            const changedKeys = Object.keys(flatSettings);
+            const deviceName = details.name ?? baseUuid;
+            const previousSettings = {};
+            if (before.success && before.config) {
+                for (const key of changedKeys) {
+                    previousSettings[key] = before.config[key] ?? null;
+                }
+            }
+            const after = await getDoorbellCameraConfig(baseUuid, extra._meta?.requestModifiers, extra.sessionId);
+            if (!after.success || !after.config) {
+                const doorbellResponse = {
+                    needUserInput: false,
+                    message: `Updated ${changedKeys.length} setting(s) on the doorbell camera "${deviceName}": ${changedKeys.join(", ")}. NOTE: the config read-back failed (${after.error ?? "unknown error"}), so the new values could not be verified.`,
+                    entityType: "doorbell-camera",
+                    entityUuid: baseUuid,
+                    success: true,
+                    updatedSettings: flatSettings,
+                    ...(before.success && before.config ? { previousSettings } : {}),
+                };
+                return {
+                    content: [{ type: "text", text: JSON.stringify(doorbellResponse) }],
+                    structuredContent: doorbellResponse,
+                };
+            }
+            const applied = [];
+            const notApplied = [];
+            const notVerifiable = [];
+            for (const key of changedKeys) {
+                const actual = after.config[key];
+                if (actual === undefined) {
+                    // getConfig doesn't report this key (e.g. camera_name / led_mode live
+                    // outside the doorbell config object), so it can't be checked here.
+                    notVerifiable.push(key);
+                }
+                else if (JSON.stringify(actual) === JSON.stringify(flatSettings[key])) {
+                    applied.push(key);
+                }
+                else {
+                    notApplied.push({ setting: key, requested: flatSettings[key], actual });
+                }
+            }
+            // api2 said success but the read-back shows every value unchanged: the
+            // write was a silent no-op. Retrying the same arguments would no-op again
+            // — surface it instead of reporting a success that didn't happen.
+            if (notApplied.length > 0 && applied.length === 0 && notVerifiable.length === 0) {
+                return errorResult(`The API accepted the update for doorbell camera "${deviceName}" but a config read-back shows the value(s) unchanged: ${notApplied
+                    .map(f => `${f.setting} is still ${JSON.stringify(f.actual)} (requested ${JSON.stringify(f.requested)})`)
+                    .join("; ")}. Do not retry with the same arguments — tell the user the setting did not take effect.`);
+            }
+            const verificationNotes = [];
+            if (notApplied.length > 0) {
+                verificationNotes.push(`WARNING — ${notApplied.length} setting(s) did NOT take effect: ${notApplied
+                    .map(f => `${f.setting} is still ${JSON.stringify(f.actual)} (requested ${JSON.stringify(f.requested)})`)
+                    .join("; ")}`);
+            }
+            if (notVerifiable.length > 0) {
+                verificationNotes.push(`${notVerifiable.length} setting(s) are not reported by the doorbell config and could not be verified: ${notVerifiable.join(", ")}`);
+            }
+            const doorbellResponse = {
+                needUserInput: false,
+                message: `Updated ${changedKeys.length} setting(s) on the doorbell camera "${deviceName}"` +
+                    (applied.length > 0
+                        ? ` — verified by reading the config back: ${applied.join(", ")}.`
+                        : `: ${changedKeys.join(", ")}.`) +
+                    (verificationNotes.length > 0 ? ` ${verificationNotes.join(". ")}.` : ""),
+                entityType: "doorbell-camera",
+                entityUuid: baseUuid,
+                success: true,
+                updatedSettings: flatSettings,
+                ...(before.success && before.config ? { previousSettings } : {}),
+                ...(notApplied.length > 0 ? { settingsNotApplied: notApplied } : {}),
+                ...(notVerifiable.length > 0 ? { settingsNotVerified: notVerifiable } : {}),
+            };
+            return {
+                content: [{ type: "text", text: JSON.stringify(doorbellResponse) }],
+                structuredContent: doorbellResponse,
+            };
+        }
+        catch (error) {
+            return errorResult(`Failed to update doorbell camera settings: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
     }
     // Step 0: Show initial form (no entityType provided)
+    const entityTypeFormResponse = {
+        needUserInput: true,
+        message: "Welcome to the Rhombus entity update tool!\n\nWhat type of entity would you like to update?\n\n• **camera** - Update camera video, audio, or device settings\n• **doorbell-camera** - Update doorbell camera video, audio, or device settings\n\nPlease specify the entity type to continue.",
+        requestType: "entity-type-selection",
+        submitAction: "update-tool",
+    };
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({
-                    needUserInput: true,
-                    message: "Welcome to the Rhombus entity update tool!\n\nWhat type of entity would you like to update?\n\n• **camera** - Update camera video, audio, or device settings\n• **climate-sensor** - Update climate sensor settings (coming soon)\n• **door-controller** - Update door controller settings (coming soon)\n• **environmental-gateway** - Update environmental gateway settings (coming soon)\n\nPlease specify the entity type to continue.",
-                    requestType: "entity-type-selection",
-                    submitAction: "update-tool",
-                }),
+                text: JSON.stringify(entityTypeFormResponse),
             },
         ],
+        structuredContent: entityTypeFormResponse,
     };
 };
 function hasCapabilitySensitiveSettings(payload) {
@@ -331,8 +461,10 @@ function hasCapabilitySensitiveSettings(payload) {
 }
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "Update Settings",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: false, destructiveHint: false },
     }, TOOL_HANDLER);
 }

package/dist/tools-console/user-access-trail-tool.js

@@ -57,8 +57,10 @@ const TOOL_HANDLER = async (args, _extra) => {
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "User Access Trail",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: true },
     }, TOOL_HANDLER);
 }

package/dist/tools-console/user-audit-tool.js

@@ -46,8 +46,10 @@ const TOOL_HANDLER = async (args, _extra) => {
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "User Audit Log",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: true },
     }, TOOL_HANDLER);
 }