rhombus-node-mcp 0.1.55 → 0.1.57

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

@@ -1,43 +1,15 @@
 import { createToolStructuredContent, extractFromToolExtra } from "../util.js";
 import { ApiPayloadSchema, OUTPUT_SCHEMA, TOOL_ARGS, } from "../types/clips-tool-types.js";
-import { getSavedClips, getExpiringClips, getSharedLiveStreams, getTimelapseClips, getClipGroups, getSharedClipGroups, createClip, deleteClip, } from "../api/clips-tool-api.js";
+import { getSavedClips, getExpiringClips, getSharedLiveStreams, getTimelapseClips, getClipGroups, getSharedClipGroups, createClip, deleteClip, updateClip, } from "../api/clips-tool-api.js";
 const TOOL_NAME = "clips-tool";
 const TOOL_DESCRIPTION = `
 Retrieves saved video clips from the Rhombus system. Saved clips can be viewed for up to 2 years and are typically found in the "Clips" tab of the "Saved Video" section of the Rhombus Console.
 Clips are either manually saved by the user, or automatically by some defined policy. Therefore, this tool
 is not for looking up the events that have occured.
 
-This tool allows you to:
-* Get saved clips or clips expiring soon (filter by devices, locations, search string, time range).
-* Get all shared live video streams for the organization.
-* Get all timelapse clips for the organization.
-
-Filter options (for saved and expiringSoon only):
-* Specific devices using their UUIDs (deviceUuidFilters).
-* Specific locations using their UUIDs (locationUuidFilters).
-* A simple string search on clip names (searchFilter).
-* A time range: start (timestampISOAfter) and/or end (timestampISOBefore) timestamp in ISO 8601 format.
-
-The tool returns a JSON object with the following structure and important fields:
-* **errorMsg (string | null):** An error message if the request failed.
-* **objecterror (boolean | null):** Indicates if an object-level error occurred.
-* **pageToken (string | null):** A token to be supplied on the next search request to get the next page of results. If this token is null, there is no more data available.
-* **savedClips (array of objects | null):** An array where each object represents a saved video clip. Each clip object contains the following important fields:
-    * **uuid (string):** The unique identifier for the video clip.
-    * **title (string):** The name given to the video clip.
-    * **description (string | null):** An optional description for the clip.
-    * **timestampMs (int64):** The start time of the video clip in milliseconds since epoch.
-    * **createdAtMs (int64):** The creation timestamp of the clip in milliseconds since epoch.
-    * **createdAtTimestamp (string):** The creation timestamp of the clip in ISO 8601 format.
-    * **deviceUuid (string):** The UUID of the primary device (e.g., camera) that recorded the clip.
-    * **deviceUuids (array of strings or null):** A list of UUIDs for all devices associated with the clip.
-    * **durationSec (int32):** The length of the video clip in seconds.
-    * **status (string):** The current processing status of the clip, with possible values such as INITIATING, UPLOADING, RENDERING, FAILED, COMPLETE, OFFLINE, or UNKNOWN.
-    * **userUuid (string | null):** The UUID of the user associated with the clip, if applicable.
-    * **sourceAlertUuid (string | null):** The UUID of the alert that triggered the creation of this clip, if any.
-* **sharedLiveVideoStreams (array):** When requestType is sharedLiveStreams, list of shared live video stream objects.
-* **timelapseClips (array):** When requestType is timelapseClips, list of timelapse clip objects.
+Set "requestType" to: get saved clips or clips expiring soon (filter by devices, locations, name search, and time range); list the org's shared live video streams, timelapse clips, clip groups, or shared clip groups; **createClip** to save a new clip from a camera's footage (video evidence around an event); or **deleteClip** to permanently delete a saved clip — destructive and irreversible, confirm with the user first.
 
+Each saved clip carries uuid, title, description, start and creation timestamps, the recording device(s), durationSec, processing status (INITIATING / UPLOADING / RENDERING / FAILED / COMPLETE / OFFLINE / UNKNOWN), and the alert that triggered it when there was one. Results paginate via pageToken (null when there is no more data).
 `;
 const TOOL_HANDLER = async (args, extra) => {
     const { requestModifiers, sessionId } = extractFromToolExtra(extra);
@@ -61,6 +33,24 @@ const TOOL_HANDLER = async (args, extra) => {
             }
             return createToolStructuredContent(await createClip(args.spliceRequest.cameraUuid, args.spliceRequest.startTimeMs, args.spliceRequest.endTimeMs, requestModifiers, sessionId));
         }
+        case "updateClip": {
+            if (!args.clipUuid) {
+                throw new Error("clipUuid is required for 'updateClip' requestType");
+            }
+            if (!args.clipTitle?.trim() && !args.clipDescription?.trim()) {
+                throw new Error("'updateClip' needs at least one of clipTitle or clipDescription — both were empty, so there is nothing to change");
+            }
+            const { existingTitle, ...result } = await updateClip(args.clipUuid, {
+                title: args.clipTitle?.trim() || undefined,
+                description: args.clipDescription?.trim() || undefined,
+            }, requestModifiers, sessionId);
+            return createToolStructuredContent({
+                ...result,
+                note: result.updateResult
+                    ? `Renamed the clip${existingTitle ? ` "${existingTitle}"` : ""}${args.clipTitle?.trim() ? ` to "${args.clipTitle.trim()}"` : ""}. Fields you did not pass were left as they were.`
+                    : undefined,
+            });
+        }
         case "deleteClip": {
             if (!args.clipUuid) {
                 throw new Error("clipUuid is required for 'deleteClip' requestType");
@@ -72,8 +62,10 @@ const TOOL_HANDLER = async (args, extra) => {
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "Clips",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: false, destructiveHint: true },
     }, TOOL_HANDLER);
 }

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

@@ -1,23 +1,36 @@
 import { z } from "zod";
 import { logger } from "../logger.js";
 export function createTool(server) {
-    server.tool("count-tool", `
-      This tool counts the number of items by accepting an array of UUIDs. It can count anything that has UUIDs - users, devices, 
+    server.registerTool("count-tool", {
+        title: "Count Items",
+        description: `
+      This tool counts the number of items by accepting an array of UUIDs. It can count anything that has UUIDs - users, devices,
       records, or any other entities. Simply provide an array of UUID strings and it will return the precise count.
-      `, {
-        uuids: z
-            .array(z.string().describe("UUID string of an individual item"))
-            .describe("An array of UUID strings representing the items to count. Each string should be a valid UUID."),
+      `,
+        inputSchema: {
+            uuids: z
+                .array(z.string().describe("UUID string of an individual item"))
+                .describe("An array of UUID strings representing the items to count. Each string should be a valid UUID."),
+        },
+        // Every result from a tool with an outputSchema must carry
+        // structuredContent or isError: true — the SDK otherwise replaces the
+        // real message with an opaque -32602 (see CLAUDE.md).
+        outputSchema: {
+            count: z.number().optional().describe("How many UUIDs were provided"),
+        },
+        annotations: { readOnlyHint: true },
     }, async ({ uuids }) => {
         try {
             logger.info("Counting UUIDs", uuids);
             return {
                 content: [{ type: "text", text: `Count: ${uuids.length}` }],
+                structuredContent: { count: uuids.length },
             };
         }
         catch (e) {
             const errorMessage = e instanceof Error ? e.message : `Unknown error: ${e}`;
             return {
+                isError: true,
                 content: [{ type: "text", text: `Error counting UUIDs: ${errorMessage}` }],
             };
         }

package/dist/tools-console/create-camera-policy-tool.js

@@ -1,141 +1,333 @@
 import { z } from "zod";
 import { createCameraPolicy } from "../api/create-camera-policy-tool-api.js";
-import { ApiPayloadSchema, OUTPUT_SCHEMA } from "../types/create-camera-policy-tool-types.js";
+import { ApiPayloadSchema, OUTPUT_SCHEMA, SCHEDULE_CONFIGS_EXAMPLE, SUGGESTED_CAMERA_ACTIVITIES, isEmptyScheduleConfigs, parseCameraUuids, parseScheduleConfigs, } from "../types/create-camera-policy-tool-types.js";
 import { postApi } from "../network/network.js";
 const TOOL_NAME = "create-camera-policy-tool";
 const TOOL_DESCRIPTION = `
-A tool for creating a camera policy that walks users through a multi-step process.
+A tool for creating a camera policy.
 
-The step begins with the user providing a policy name, description, and organization UUID.
-Then, the user is presented with a form to configure the schedules for the policy.
-Finally, the user is presented with a form to assign the policy to cameras.
+Preferred (single call): pass name, description, orgUuid, scheduleConfigs, and cameraUuids together — the tool creates the policy, configures its schedule triggers, and assigns the cameras all in one call. Omit policyUuid; it is created for you.
 
-Uses elicitation forms for rich user interaction.
+Legacy step-by-step: calling with only a subset of args advances one phase at a time (name/description/orgUuid to create → policyUuid+scheduleConfigs for schedules → policyUuid+cameraUuids for camera assignment).
+
+Errors are labelled: a "RETRYABLE" error means nothing was written and you should call again with corrected arguments; a "PARTIAL STATE" error means part of the policy now exists and you must stop and report it.
 `;
+// All args are optional: each step of the flow uses a different subset, and
+// requiring the unused ones forces callers to pad with "" — the guided
+// workflow's "pass ONLY this step's args" instruction then fails validation.
 const TOOL_ARGS = {
     // Step 1: Policy creation
-    name: z.string().describe("Policy name (for creating policy)"),
-    description: z.string().describe("Policy description (for creating policy)"),
-    orgUuid: z.string().describe("Organization UUID (for creating policy)"),
+    name: z.string().optional().describe("Policy name (for creating policy)"),
+    description: z.string().optional().describe("Policy description (for creating policy)"),
+    orgUuid: z.string().optional().describe("Organization UUID (for creating policy)"),
     // Step 2: Schedule configuration
-    policyUuid: z.string().describe("Policy UUID (for configuring schedules)"),
-    scheduleConfigs: z.string().describe("JSON string of schedule configurations"),
+    policyUuid: z
+        .string()
+        .optional()
+        .describe("Policy UUID of an EXISTING policy (for configuring schedules or assigning cameras on an already-created policy). Omit it when creating a policy — including on a single full call that also passes scheduleConfigs and cameraUuids."),
+    scheduleConfigs: z
+        .string()
+        .optional()
+        .describe(`JSON array string of schedule configurations: [{"scheduleUuid": <uuid>, "activities": [<activity>, ...]}]. ` +
+        `"activities" must be a real JSON array of activity strings, not a string containing an array, and each ` +
+        `value must be an API activity constant (e.g. ${SUGGESTED_CAMERA_ACTIVITIES.slice(0, 6).join(", ")}) — ` +
+        `never a display label like "Human Movement". Example: ${SCHEDULE_CONFIGS_EXAMPLE}`),
     // Step 3: Camera assignment
-    cameraUuids: z.string().describe("Comma-separated camera UUIDs to assign policy to"),
-    policyName: z.string().describe("Policy name (for reference)"),
+    cameraUuids: z
+        .string()
+        .optional()
+        .describe('Comma-separated camera UUIDs to assign policy to, e.g. "uuidA,uuidB". Camera uuids only — resolve names to uuids first.'),
+    policyName: z.string().optional().describe("Policy name (for reference)"),
 };
 const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+// Every result from this tool MUST carry structuredContent: the tool registers
+// an outputSchema, and the MCP SDK rejects any result without structuredContent
+// as "MCP error -32602" — which REPLACES the real failure text and historically
+// made the model (and user) see a validation crash instead of the API error.
+function errorResult(text) {
+    return {
+        isError: true,
+        content: [{ type: "text", text }],
+        structuredContent: { needUserInput: false, message: text },
+    };
+}
+// Errors are labelled by whether anything was written, because the caller cannot
+// otherwise tell. The guided workflow says "on error, STOP and make no further
+// calls" — correct after a partial mutation (a retry would create a SECOND
+// policy) and wrong before one, where a corrected retry is free. Prod 2026-08-04:
+// a malformed `scheduleConfigs` was rejected before any write, the model stopped
+// and apologized, and the identical request succeeded when the user asked again.
+const RETRYABLE_PREFIX = "RETRYABLE — nothing was created or changed by this call.";
+const PARTIAL_PREFIX = "PARTIAL STATE — do NOT retry this call and do NOT create another policy.";
+const RETRY_INSTRUCTION = "Fix the arguments named above, then call this tool ONCE more with corrected arguments. Do not tell the user the policy could not be created unless a corrected retry also fails.";
+function retryableError(detail) {
+    return errorResult(`${RETRYABLE_PREFIX} ${detail} ${RETRY_INSTRUCTION}`);
+}
+/** Retryable, but a policy from an earlier call already exists — don't re-create it. */
+function retryableStepError(detail, existingPolicyUuid) {
+    return errorResult(`${RETRYABLE_PREFIX} Policy ${existingPolicyUuid} already exists from an earlier call — do NOT create another one. ${detail} ${RETRY_INSTRUCTION}`);
+}
+function partialStateError(detail) {
+    return errorResult(`${PARTIAL_PREFIX} ${detail} Report exactly this state to the user.`);
+}
+// postApi returns {error: true, status: "..."} on transport/HTTP failures and
+// domain errors arrive as {error: true, errorMsg: "..."} — normalize both.
+function apiErrorText(result) {
+    return (result.errorMsg?.trim() ||
+        result.status?.trim() ||
+        "the Rhombus API reported a failure without a message");
+}
+/** api2 can succeed while reporting a caveat; dropping it hides real problems. */
+function apiWarningSuffix(result) {
+    const warning = result.warningMsg?.trim();
+    return warning ? ` Note from the API: ${warning}` : "";
+}
 const TOOL_HANDLER = async (args, extra) => {
     const { name, description, orgUuid, policyUuid, scheduleConfigs, cameraUuids, policyName } = args;
+    // An empty list is how the legacy step-1 call spells "no schedules yet", so it
+    // must not select the schedule phase. Detected by parsing, not by comparing to
+    // the literal "[]" — "[ ]" and "\"[]\"" used to slip past that compare and
+    // fall through into policy creation, silently creating a DUPLICATE policy.
+    const hasScheduleConfigs = Boolean(scheduleConfigs?.trim() && !isEmptyScheduleConfigs(scheduleConfigs));
+    const hasFullInputSet = Boolean(name?.trim() && hasScheduleConfigs && cameraUuids?.trim());
+    // A full input set PLUS a policyUuid is ambiguous: create everything, or treat
+    // the uuid as an existing policy? It used to silently fall through to
+    // camera-assignment-only and then report "setup completely finished" for a
+    // policy whose schedules were never configured.
+    if (hasFullInputSet && policyUuid?.trim()) {
+        return retryableError(`Ambiguous arguments: name, scheduleConfigs, and cameraUuids were all provided (a full creation call) together with policyUuid "${policyUuid.trim()}". ` +
+            `To create a new policy, drop policyUuid. To modify the existing policy ${policyUuid.trim()}, drop name and send policyUuid with ONE of scheduleConfigs or cameraUuids.`);
+    }
+    // Full run: all inputs present and no pre-existing policyUuid — create the
+    // policy, configure schedules, and assign cameras in ONE call. The guided
+    // workflow collects everything before confirming, and executing across three
+    // model round trips proved fragile: the model wobbles at each call boundary
+    // (re-renders forms, splits args wrong), so the boundaries are removed.
+    if (hasFullInputSet) {
+        // Validate BOTH structured inputs BEFORE any mutation, so anything wrong
+        // with them is a clean retryable failure rather than a half-built policy.
+        const parsedConfigs = parseScheduleConfigs(scheduleConfigs);
+        if (!parsedConfigs.ok) {
+            return retryableError(parsedConfigs.message);
+        }
+        const parsedCameras = parseCameraUuids(cameraUuids);
+        if (!parsedCameras.ok) {
+            return retryableError(parsedCameras.message);
+        }
+        const scheduledTriggers = parsedConfigs.value.map(config => ({
+            scheduleUuid: config.scheduleUuid,
+            triggerSet: config.activities.map(activity => ({ activity })),
+        }));
+        const cameraList = parsedCameras.value;
+        // Phase 1: create.
+        let createdUuid;
+        let createWarning = "";
+        try {
+            const payload = ApiPayloadSchema.parse({
+                policy: {
+                    name,
+                    description: description?.trim() ? description : undefined,
+                    orgUuid: orgUuid?.trim() ? orgUuid : undefined,
+                    scheduledTriggers: [],
+                },
+            });
+            const result = await createCameraPolicy(payload, extra._meta?.requestModifiers, extra.sessionId);
+            if (result.error) {
+                return retryableError(`Creating the policy failed: ${apiErrorText(result)}.`);
+            }
+            if (!result.policyUuid) {
+                return retryableError("Creating the policy returned no policyUuid, so it did not succeed.");
+            }
+            createdUuid = result.policyUuid;
+            createWarning = apiWarningSuffix(result);
+        }
+        catch (error) {
+            return retryableError(`Creating the policy failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
+        }
+        // Phase 2: schedules (updateCameraPolicy REPLACES the policy object, so
+        // resend the identity fields — see the legacy schedule branch below).
+        try {
+            const result = await postApi({
+                route: "/policy/updateCameraPolicy",
+                body: {
+                    policy: {
+                        uuid: createdUuid,
+                        name,
+                        description: description?.trim() ? description : undefined,
+                        scheduledTriggers,
+                    },
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result.error) {
+                return partialStateError(`Policy "${name}" was created (uuid ${createdUuid}) but configuring its schedules failed: ${apiErrorText(result)}. No cameras were assigned.`);
+            }
+            createWarning += apiWarningSuffix(result);
+        }
+        catch (error) {
+            return partialStateError(`Policy "${name}" was created (uuid ${createdUuid}) but configuring its schedules failed: ${error instanceof Error ? error.message : "Unknown error"}. No cameras were assigned.`);
+        }
+        // Phase 3: cameras.
+        try {
+            const result = await postApi({
+                route: "/camera/updateDetailsBulkV2",
+                body: {
+                    cameraBulkDetails: cameraList.map(cameraUuid => ({
+                        uuid: cameraUuid,
+                        policyUuid: createdUuid,
+                        policyUuidUpdated: true,
+                    })),
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result?.error) {
+                return partialStateError(`Policy "${name}" was created with its schedules (uuid ${createdUuid}) but camera assignment failed: ${apiErrorText(result)}.`);
+            }
+            createWarning += apiWarningSuffix(result);
+        }
+        catch (error) {
+            return partialStateError(`Policy "${name}" was created with its schedules (uuid ${createdUuid}) but camera assignment failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
+        }
+        const fullRunResponse = {
+            needUserInput: false,
+            message: `Policy "${name}" created with ${scheduledTriggers.length} schedule trigger(s) and assigned to ${cameraList.length} camera(s).${createWarning}`,
+            policyUuid: createdUuid,
+            policyName: name,
+        };
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `🎉 Camera policy setup completely finished!\n\n✅ Policy "${name}" created with ${scheduledTriggers.length} schedule trigger(s)\n✅ Assigned to ${cameraList.length} camera(s)\n✅ Policy is now fully active${createWarning}`,
+                },
+            ],
+            structuredContent: fullRunResponse,
+        };
+    }
     // Step 3: Camera assignment (if cameraUuids provided)
     if (cameraUuids?.trim()) {
+        // Guard BEFORE the API call: an empty policyUuid here would write
+        // policyUuid: "" with policyUuidUpdated: true to every listed camera —
+        // i.e. UNASSIGN their existing policies, not assign the new one.
+        if (!policyUuid?.trim()) {
+            return retryableError(`Cannot assign cameras: policyUuid is empty, so the policy has not been created yet. ` +
+                `Either pass the full set (name, scheduleConfigs, cameraUuids) in one call to create everything at once, or create the policy first (name/description/orgUuid call) and pass the returned policyUuid.`);
+        }
+        const parsedCameras = parseCameraUuids(cameraUuids);
+        if (!parsedCameras.ok) {
+            // Previously an unusable cameraUuids string (e.g. ",") left this branch
+            // with no return at all and fell through into policy creation, creating a
+            // duplicate policy and reporting success.
+            return retryableStepError(parsedCameras.message, policyUuid.trim());
+        }
+        const cameraList = parsedCameras.value;
         try {
-            const cameraList = cameraUuids
-                .split(",")
-                .map((uuid) => uuid.trim())
-                .filter((uuid) => uuid);
-            if (cameraList.length > 0) {
-                const cameraPayload = {
+            const result = await postApi({
+                route: "/camera/updateDetailsBulkV2",
+                body: {
                     cameraBulkDetails: cameraList.map(cameraUuid => ({
                         uuid: cameraUuid,
                         policyUuid: policyUuid,
                         policyUuidUpdated: true,
                     })),
-                };
-                await postApi({
-                    route: "/camera/updateDetailsBulkV2",
-                    body: cameraPayload,
-                    modifiers: extra._meta?.requestModifiers,
-                    sessionId: extra.sessionId,
-                });
-                const jsonResultResponse = {
-                    needUserInput: false,
-                    message: `Excellent! Policy created and assigned to ${cameraList.length} camera(s)!`,
-                    policyUuid,
-                    policyName,
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `🎉 Camera policy setup completely finished!\n\n✅ Policy "${policyName}" assigned to ${cameraList.length} camera(s)\n✅ Policy is now fully active\n\nYour cameras will now generate alerts according to the policy configuration.`,
-                        },
-                    ],
-                    structuredContent: jsonResultResponse,
-                };
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result?.error) {
+                // Assigning cameras is idempotent, so a corrected retry is safe — but
+                // the policy itself already exists and must not be created again.
+                return retryableStepError(`Assigning the policy to the cameras failed: ${apiErrorText(result)}.`, policyUuid);
             }
-        }
-        catch (error) {
+            const warning = apiWarningSuffix(result);
+            const jsonResultResponse = {
+                needUserInput: false,
+                message: `Policy "${policyName?.trim() || policyUuid}" assigned to ${cameraList.length} camera(s).${warning}`,
+                policyUuid,
+                policyName,
+            };
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Failed to assign policy to cameras: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        // Claims only what THIS call did: schedules may or may not have been
+                        // configured by an earlier call, and this branch cannot know.
+                        text: `✅ Policy "${policyName?.trim() || policyUuid}" assigned to ${cameraList.length} camera(s).${warning}`,
                     },
                 ],
+                structuredContent: jsonResultResponse,
             };
         }
+        catch (error) {
+            return retryableStepError(`Assigning the policy to the cameras failed: ${error instanceof Error ? error.message : "Unknown error"}.`, policyUuid);
+        }
     }
     // Step 2: Schedule configuration (if scheduleConfigs provided and non-empty)
-    if (scheduleConfigs?.trim() && scheduleConfigs.trim() !== "[]") {
+    if (hasScheduleConfigs) {
+        if (!policyUuid?.trim()) {
+            return retryableError(`Cannot configure schedules: policyUuid is empty. Create the policy first (name/description/orgUuid call) and pass the returned policyUuid, or pass the full set (name, scheduleConfigs, cameraUuids) in one call to do everything at once.`);
+        }
+        const parsedConfigs = parseScheduleConfigs(scheduleConfigs);
+        if (!parsedConfigs.ok) {
+            return retryableStepError(parsedConfigs.message, policyUuid.trim());
+        }
+        const scheduledTriggers = parsedConfigs.value.map(config => ({
+            scheduleUuid: config.scheduleUuid,
+            triggerSet: config.activities.map(activity => ({ activity })),
+        }));
+        // /policy/updateCameraPolicy has REPLACE semantics: any field omitted
+        // from the policy object is NULLED on the stored policy. Sending only
+        // {uuid, scheduledTriggers} erases the name/description that step 1
+        // just set (observed in ITG: wizard-created policies with name: null,
+        // invisible in the Console). Always resend the identity fields.
+        const effectiveName = policyName?.trim() || name?.trim();
+        if (!effectiveName) {
+            return retryableStepError(`Cannot configure schedules: policyName is required — updateCameraPolicy replaces the whole policy object, so omitting the name would erase it. Pass policyName (and description, if any) along with policyUuid and scheduleConfigs.`, policyUuid.trim());
+        }
         try {
-            const configs = JSON.parse(scheduleConfigs);
-            // Only proceed if we have actual schedule configurations
-            if (configs.length > 0) {
-                const scheduledTriggers = configs.map(config => ({
-                    scheduleUuid: config.scheduleUuid,
-                    triggerSet: config.activities.map(activity => ({ activity })),
-                }));
-                const payload = {
-                    policy: { uuid: policyUuid, scheduledTriggers },
-                };
-                const result = await postApi({
-                    route: "/policy/updateCameraPolicy",
-                    body: payload,
-                    modifiers: extra._meta?.requestModifiers,
-                    sessionId: extra.sessionId,
-                });
-                if (result.error) {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Failed to configure policy schedules: ${result.errorMsg || "Unknown error"}`,
-                            },
-                        ],
-                    };
-                }
-                // Success - now show camera assignment form
-                const jsonResultResponse = {
-                    needUserInput: true,
-                    message: `Excellent! Policy schedules configured.\n\nFinal step: Please select which cameras should use this policy.`,
-                    requestType: "camera-assignment",
-                    submitAction: "create-camera-policy-tool",
-                    policyUuid,
-                    policyName,
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(jsonResultResponse),
-                        },
-                    ],
-                    structuredContent: jsonResultResponse,
-                };
+            const result = await postApi({
+                route: "/policy/updateCameraPolicy",
+                body: {
+                    policy: {
+                        uuid: policyUuid,
+                        name: effectiveName,
+                        description: description?.trim() ? description : undefined,
+                        scheduledTriggers,
+                    },
+                },
+                modifiers: extra._meta?.requestModifiers,
+                sessionId: extra.sessionId,
+            });
+            if (result.error) {
+                // Replacing the schedules is idempotent — safe to retry, as long as the
+                // policy is not created a second time.
+                return retryableStepError(`Configuring the policy schedules failed: ${apiErrorText(result)}.`, policyUuid);
             }
-            // If configs.length === 0, fall through to policy creation
-        }
-        catch (error) {
+            // Neutral, fact-only message: imperative text like "Please select
+            // which cameras..." is an instruction the model follows over the
+            // workflow playbook (observed: it re-rendered the confirm form or
+            // stopped mid-execution to ask for cameras it already had).
+            const jsonResultResponse = {
+                needUserInput: false,
+                message: `Schedules configured for policy "${effectiveName}" (${policyUuid}).${apiWarningSuffix(result)}`,
+                policyUuid,
+                policyName,
+            };
             return {
                 content: [
                     {
                         type: "text",
-                        text: `Error configuring schedules: ${error instanceof Error ? error.message : "Unknown error"}`,
+                        text: JSON.stringify(jsonResultResponse),
                     },
                 ],
+                structuredContent: jsonResultResponse,
             };
         }
+        catch (error) {
+            return retryableStepError(`Configuring the policy schedules failed: ${error instanceof Error ? error.message : "Unknown error"}.`, policyUuid);
+        }
     }
     // Step 1: Policy creation (if name provided)
     if (name?.trim()) {
@@ -150,22 +342,16 @@ const TOOL_HANDLER = async (args, extra) => {
             });
             const result = await createCameraPolicy(payload, extra._meta?.requestModifiers, extra.sessionId);
             if (result.error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Failed to create camera policy: ${result.errorMsg || "Unknown error"}`,
-                        },
-                    ],
-                };
+                return retryableError(`Creating the policy failed: ${apiErrorText(result)}.`);
+            }
+            if (!result.policyUuid) {
+                return retryableError("Creating the policy returned no policyUuid, so it did not succeed.");
             }
-            console.error(`[createCameraPolicyTool] -- Proceeding with schedule-trigger-configuration form. Got result ${JSON.stringify(result)}`);
-            // Success - now show schedule configuration form
+            console.error(`[createCameraPolicyTool] -- Policy created. Got result ${JSON.stringify(result)}`);
+            // Neutral, fact-only message (see the schedule-step comment above).
             const jsonResultResponse = {
-                needUserInput: true,
-                message: `Great! Your policy "${name}" was created with UUID: ${result.policyUuid}\n\nNext, let's configure when this policy should be active and what activities should trigger alerts.`,
-                requestType: "schedule-trigger-configuration",
-                submitAction: "create-camera-policy-tool",
+                needUserInput: false,
+                message: `Policy "${name}" created with UUID: ${result.policyUuid}${apiWarningSuffix(result)}`,
                 policyUuid: result.policyUuid,
                 policyName: name,
             };
@@ -180,35 +366,31 @@ const TOOL_HANDLER = async (args, extra) => {
             };
         }
         catch (error) {
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: `Error creating camera policy: ${error instanceof Error ? error.message : "Unknown error"}`,
-                    },
-                ],
-            };
+            return retryableError(`Creating the policy failed: ${error instanceof Error ? error.message : "Unknown error"}.`);
         }
     }
-    // Step 0: Show initial form (no args provided)
+    // Step 0: no args provided — tell the caller what's needed (plain facts, no
+    // legacy elicitation requestType/submitAction hints).
+    const initialFormResponse = {
+        needUserInput: true,
+        message: "No policy was created — this call had no arguments. To create a camera policy, collect from the user: a policy name (required), an optional description, the schedule triggers, and the cameras to assign, then call this tool again with name, description, orgUuid, scheduleConfigs, and cameraUuids together.",
+    };
     return {
         content: [
             {
                 type: "text",
-                text: JSON.stringify({
-                    needUserInput: true,
-                    message: "Please provide the following information to create your camera policy:\n\n1. **Policy Name** (required): A descriptive name for the policy\n2. **Policy Description** (optional): What this policy does\n3. **Organization UUID** (optional): Leave blank to use your current organization\n\nOnce you provide this information, I'll create the policy for you.",
-                    requestType: "policy-creation-form",
-                    submitAction: "create-camera-policy-tool",
-                }),
+                text: JSON.stringify(initialFormResponse),
             },
         ],
+        structuredContent: initialFormResponse,
     };
 };
 export function createTool(server) {
     server.registerTool(TOOL_NAME, {
+        title: "Create Camera Policy",
         description: TOOL_DESCRIPTION,
         inputSchema: TOOL_ARGS,
         outputSchema: OUTPUT_SCHEMA.shape,
+        annotations: { readOnlyHint: false, destructiveHint: false },
     }, TOOL_HANDLER);
 }