rhombus-node-mcp 0.1.15 → 0.1.17

package/dist/services/faiss-search-service.js

@@ -0,0 +1,261 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import faiss from 'faiss-node';
+import { EmbeddingService } from './embedding-service.js';
+// Constants following coding style guidelines
+const FAISS_INDEX_TYPE = 'IndexFlatIP'; // Inner Product for cosine similarity
+const SEARCH_RESULTS_LIMIT = 50;
+const SIMILARITY_THRESHOLD = 0.3;
+const EMBEDDING_DIMENSIONS = 1536; // text-embedding-3-small dimensions
+// Get project root directory - resolves relative to the current module file
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = path.resolve(__dirname, '../..');
+const EMBEDDINGS_DATA_PATH = path.join(PROJECT_ROOT, 'data/embeddings/embeddings.json');
+const FAISS_INDEX_PATH = path.join(PROJECT_ROOT, 'data/embeddings/faiss.index');
+export class FaissSearchService {
+    index = null;
+    embeddings = [];
+    embeddingService;
+    constructor() {
+        this.embeddingService = new EmbeddingService();
+    }
+    /**
+     * Load embeddings from file and build FAISS index
+     * @param embeddingsPath - Path to embeddings.json file (optional, defaults to project data directory)
+     */
+    async loadEmbeddings(embeddingsPath) {
+        const resolvedEmbeddingsPath = embeddingsPath || EMBEDDINGS_DATA_PATH;
+        console.log(`📚 Loading embeddings from ${resolvedEmbeddingsPath}...`);
+        try {
+            const fileContent = await fs.readFile(resolvedEmbeddingsPath, 'utf-8');
+            this.embeddings = JSON.parse(fileContent);
+            if (!Array.isArray(this.embeddings)) {
+                throw new Error('Embeddings file does not contain a valid array');
+            }
+            console.log(`✅ Loaded ${this.embeddings.length} embeddings`);
+            // Validate embedding dimensions
+            if (this.embeddings.length > 0) {
+                const firstEmbedding = this.embeddings[0];
+                if (!firstEmbedding.embedding || firstEmbedding.embedding.length !== EMBEDDING_DIMENSIONS) {
+                    throw new Error(`Invalid embedding dimensions. Expected ${EMBEDDING_DIMENSIONS}, got ${firstEmbedding.embedding?.length || 0}`);
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load embeddings: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Build FAISS index from loaded embeddings
+     */
+    async buildIndex() {
+        if (this.embeddings.length === 0) {
+            throw new Error('No embeddings loaded. Call loadEmbeddings() first.');
+        }
+        console.log(`🏗️ Building FAISS index with ${this.embeddings.length} vectors...`);
+        const startTime = Date.now();
+        try {
+            // Create FAISS index for inner product (cosine similarity with normalized vectors)
+            this.index = new faiss.IndexFlatIP(EMBEDDING_DIMENSIONS);
+            // Prepare embeddings matrix
+            const embeddingMatrix = new Float32Array(this.embeddings.length * EMBEDDING_DIMENSIONS);
+            for (let i = 0; i < this.embeddings.length; i++) {
+                const embedding = this.embeddings[i].embedding;
+                // Normalize the embedding for cosine similarity
+                const normalizedEmbedding = this.normalizeVector(embedding);
+                // Copy normalized embedding to matrix
+                for (let j = 0; j < EMBEDDING_DIMENSIONS; j++) {
+                    embeddingMatrix[i * EMBEDDING_DIMENSIONS + j] = normalizedEmbedding[j];
+                }
+            }
+            // Add vectors to index
+            this.index.add(Array.from(embeddingMatrix));
+            const buildTime = Date.now() - startTime;
+            console.log(`✅ FAISS index built successfully in ${buildTime}ms`);
+            console.log(`   📊 Index type: ${FAISS_INDEX_TYPE}`);
+            console.log(`   📏 Dimensions: ${EMBEDDING_DIMENSIONS}`);
+            console.log(`   🔢 Total vectors: ${this.index.ntotal()}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to build FAISS index: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Save FAISS index to file
+     * @param indexPath - Path to save the index file
+     */
+    async saveIndex(indexPath) {
+        if (!this.index) {
+            throw new Error('No index built. Call buildIndex() first.');
+        }
+        console.log(`💾 Saving FAISS index to ${indexPath}...`);
+        try {
+            // Ensure directory exists
+            const indexDir = path.dirname(indexPath);
+            await fs.mkdir(indexDir, { recursive: true });
+            // Save the index
+            this.index.write(indexPath);
+            console.log(`✅ Index saved successfully`);
+        }
+        catch (error) {
+            throw new Error(`Failed to save FAISS index: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Load FAISS index from file
+     * @param indexPath - Path to the index file (optional, defaults to project data directory)
+     */
+    async loadIndex(indexPath) {
+        const resolvedIndexPath = indexPath || FAISS_INDEX_PATH;
+        console.log(`📖 Loading FAISS index from ${resolvedIndexPath}...`);
+        try {
+            this.index = faiss.IndexFlatIP.read(resolvedIndexPath);
+            console.log(`✅ Index loaded successfully`);
+            console.log(`   📏 Dimensions: ${EMBEDDING_DIMENSIONS}`);
+            console.log(`   🔢 Total vectors: ${this.index.ntotal()}`);
+            // Note: IndexFlatIP doesn't expose dimension property directly
+            // We validate using our known dimensions constant
+        }
+        catch (error) {
+            throw new Error(`Failed to load FAISS index: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Search for similar vectors using natural language query
+     * @param params - Search parameters
+     * @returns Search results with metadata
+     */
+    async search(params) {
+        if (!this.index) {
+            throw new Error('No index loaded. Call loadIndex() or buildIndex() first.');
+        }
+        if (this.embeddings.length === 0) {
+            throw new Error('No embeddings metadata loaded. Call loadEmbeddings() first.');
+        }
+        const startTime = Date.now();
+        try {
+            // Generate embedding for the query
+            console.log(`🔍 Searching for: "${params.query}"`);
+            const queryEmbeddingResult = await this.embeddingService.generateSingleEmbedding(params.query, `query-${Date.now()}`);
+            // Normalize query embedding for cosine similarity
+            const normalizedQueryEmbedding = this.normalizeVector(queryEmbeddingResult.embedding);
+            // Determine search parameters
+            const searchLimit = Math.min(params.limit || SEARCH_RESULTS_LIMIT, this.embeddings.length);
+            const similarityThreshold = params.minSimilarity || SIMILARITY_THRESHOLD;
+            // Perform FAISS search
+            const searchResults = this.index.search(normalizedQueryEmbedding, searchLimit);
+            // Process results
+            const results = [];
+            let filteredCount = 0;
+            for (let i = 0; i < searchResults.labels.length; i++) {
+                const vectorIndex = searchResults.labels[i];
+                const similarity = searchResults.distances[i]; // Inner product similarity
+                // Skip invalid indices
+                if (vectorIndex < 0 || vectorIndex >= this.embeddings.length) {
+                    continue;
+                }
+                // Apply similarity threshold
+                if (similarity < similarityThreshold) {
+                    filteredCount++;
+                    continue;
+                }
+                const embedding = this.embeddings[vectorIndex];
+                // Apply URL pattern filter if specified
+                if (params.urlPattern && !embedding.sourceUrl.includes(params.urlPattern)) {
+                    filteredCount++;
+                    continue;
+                }
+                results.push({
+                    chunkText: embedding.chunkText,
+                    sourceUrl: embedding.sourceUrl,
+                    sourceTitle: embedding.sourceTitle,
+                    similarity: similarity,
+                    chunkId: embedding.chunkId,
+                    chunkIndex: embedding.chunkIndex,
+                    tokenCount: embedding.tokenCount,
+                    metadata: embedding.metadata,
+                });
+            }
+            const searchTime = Date.now() - startTime;
+            const stats = {
+                totalVectors: this.index.ntotal(),
+                searchTime,
+                resultsReturned: results.length,
+                resultsFiltered: filteredCount,
+            };
+            console.log(`✅ Search completed in ${searchTime}ms`);
+            console.log(`   🔍 Query tokens: ${queryEmbeddingResult.tokenCount}`);
+            console.log(`   📊 Results found: ${results.length}`);
+            console.log(`   🚫 Results filtered: ${filteredCount}`);
+            return { results, stats };
+        }
+        catch (error) {
+            throw new Error(`Search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /**
+     * Get index statistics
+     */
+    getIndexStats() {
+        if (!this.index) {
+            return null;
+        }
+        return {
+            totalVectors: this.index.ntotal(),
+            dimensions: EMBEDDING_DIMENSIONS,
+            indexType: FAISS_INDEX_TYPE,
+        };
+    }
+    /**
+     * Normalize vector for cosine similarity computation
+     * @param vector - Input vector
+     * @returns Normalized vector
+     */
+    normalizeVector(vector) {
+        const magnitude = Math.sqrt(vector.reduce((sum, val) => sum + val * val, 0));
+        if (magnitude === 0) {
+            return vector.slice(); // Return copy of zero vector
+        }
+        return vector.map(val => val / magnitude);
+    }
+    /**
+     * Validate embeddings data integrity
+     */
+    validateEmbeddings() {
+        const errors = [];
+        if (this.embeddings.length === 0) {
+            errors.push('No embeddings loaded');
+            return { isValid: false, errors };
+        }
+        // Check each embedding
+        for (let i = 0; i < Math.min(this.embeddings.length, 10); i++) { // Sample first 10
+            const embedding = this.embeddings[i];
+            if (!embedding.chunkId) {
+                errors.push(`Embedding ${i}: Missing chunkId`);
+            }
+            if (!embedding.embedding || embedding.embedding.length !== EMBEDDING_DIMENSIONS) {
+                errors.push(`Embedding ${i}: Invalid embedding dimensions`);
+            }
+            if (!embedding.chunkText || embedding.chunkText.trim().length === 0) {
+                errors.push(`Embedding ${i}: Missing or empty chunkText`);
+            }
+            if (!embedding.sourceUrl) {
+                errors.push(`Embedding ${i}: Missing sourceUrl`);
+            }
+        }
+        return {
+            isValid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Clean up resources
+     */
+    dispose() {
+        // FAISS resources are automatically cleaned up
+        this.index = null;
+        this.embeddings = [];
+    }
+}

package/dist/tools/camera-tool.js

@@ -0,0 +1,100 @@
+import { getLogger } from "../logger.js";
+import { getCameraSettings, getImageForCameraAtTime } from "../api/camera-tool-api.js";
+import { BASE_TOOL_ARGS } from "../types/camera-tool-types.js";
+const TOOL_NAME = "camera-tool";
+const TOOL_DESCRIPTION = `
+This tool can perform some action pertaining to the video stream of a camera. There are two types of requests
+that can be passed into "requestType":
+- image
+- get-settings
+
+What follows is a description of the behavior of this tool given the requestType "image"
+
+This tool should be used any time someone wants to specify a subset of cameras to use for a task, based on some features that the camera sees.  For example, interior cameras, cameras facing the street, cameras with a view of X, Y, Z, etc.
+
+For instance if someone says "I want X using cameras with Y" then this tool should get a snapshot of the image to answer the question of if the camera satisfies the Y predicate.
+
+This tool captures and returns a real-time snapshot from a designated security camera.
+The image reflects the current scene in the camera's field of view and serves as a contextual
+input source for downstream tasks such as object recognition, anomaly detection, incident investigation,
+or situational assessment. When invoked, the tool provides the following: 
+•  Visual Scene Capture: A high-resolution image of what the camera is actively observing, including people, vehicles, license plates, and any detectable objects.  
+
+What follows is a description of the behavior of this tool given the requestType "get-settings"
+
+This tool retrieves the current configuration for a specified camera or associated device (e.g., sensor, access controller). The returned JSON object can include detailed camera settings (e.g., resolution, bitrate) and various device-specific configurations (e.g. storage settings).
+
+NOTE: To update camera settings, use the update-tool instead.
+`;
+const logger = getLogger("camera-tool");
+const TOOL_ARGS = BASE_TOOL_ARGS;
+const TOOL_HANDLER = async (args, extra) => {
+    const { cameraUuid, timestampISO, requestType } = args;
+    if (!cameraUuid) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        needUserInput: true,
+                        commandForUser: "Which camera are you talking about?",
+                    }),
+                },
+            ],
+        };
+    }
+    let response;
+    const timestampMs = timestampISO
+        ? new Date(timestampISO).getTime()
+        : new Date().getTime() - 1000 * 60 * 5;
+    switch (requestType) {
+        case "image":
+            response = await getImageForCameraAtTime(cameraUuid, timestampMs, extra._meta?.requestModifiers, extra.sessionId);
+            if (!response.success || !response.imageData) {
+                return {
+                    content: [{ type: "text", text: JSON.stringify(response) }],
+                };
+            }
+            logger.debug(`Received image response:\n ${JSON.stringify(response)}`);
+            return {
+                content: [
+                    {
+                        type: "image",
+                        data: response.imageData,
+                        mimeType: "image/jpeg",
+                    },
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            status: "image-attached",
+                            cameraUuid,
+                            timestampMs,
+                        }),
+                    },
+                ],
+            };
+        case "get-settings":
+            response = await getCameraSettings(cameraUuid, extra._meta?.requestModifiers, extra.sessionId);
+            return {
+                content: [{ type: "text", text: JSON.stringify(response) }],
+            };
+        default:
+            response = {
+                error: true,
+                status: "missing unknown type from tool call",
+            };
+            break;
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({ response }),
+            },
+        ],
+    };
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
+}

package/dist/tools/clips-tool.js

@@ -1,37 +1,15 @@
-import { z } from "zod";
-import { postApi } from "../network.js";
-const ClipsArgs = z.object({
-    deviceUuidFilters: z
-        .array(z.string())
-        .optional()
-        .describe("A list of UUIDs representing specific devices to filter clips by. Only clips emitted by these devices will be returned."),
-    locationUuidFilters: z
-        .array(z.string())
-        .optional()
-        .describe("A list of UUIDs representing specific locations to filter clips by. Only clips associated with these locations will be returned."),
-    searchFilter: z
-        .string()
-        .optional()
-        .describe("A simple string to search for within the names of the clips."),
-    timestampMsAfter: z
-        .number()
-        .describe("The start of the time range (in milliseconds since epoch) for which to retrieve clips. Only clips that occurred AFTER this timestamp will be returned."),
-    timestampMsBefore: z
-        .number()
-        .describe("The end of the time range (in milliseconds since epoch) for which to retrieve clips. Only clips that occurred BEFORE this timestamp will be returned."),
-});
-async function getSavedClips(args, requestModifiers) {
-    return await postApi("/event/getClipsWithProgress", args, requestModifiers);
-}
-export function createTool(server) {
-    server.tool("clips-tool", `
+import { ApiPayloadSchema, TOOL_ARGS } from "../types/clips-tool-types.js";
+import { getSavedClips, getExpiringClips } 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.
 
 This tool allows you to filter clips by:
+* Whether or not they are expiring soon.
 * Specific devices using their UUIDs.
 * Specific locations using their UUIDs.
 * A simple string search on clip names.
-* A time range, specifying a start (timestampMsAfter) and/or end (timestampMsBefore) timestamp in milliseconds since epoch.
+* A time range, specifying a 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.
@@ -43,19 +21,27 @@ The tool returns a JSON object with the following structure and important fields
     * **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.
-`, {
-        ...ClipsArgs.shape,
-    }, async ({ ...args }, extra) => {
-        let ret;
-        ret = await getSavedClips(args, extra._meta?.requestModifiers);
-        return {
-            content: [{ type: "text", text: JSON.stringify(ret) }],
-        };
-    });
+`;
+const TOOL_HANDLER = async (args, extra) => {
+    const payload = ApiPayloadSchema.parse(args);
+    let ret;
+    switch (args.queryType) {
+        case "saved":
+            ret = await getSavedClips(payload, extra._meta?.requestModifiers, extra.sessionId);
+        case "expiringSoon":
+            ret = await getExpiringClips(payload, extra._meta?.requestModifiers, extra.sessionId);
+    }
+    return {
+        content: [{ type: "text", text: JSON.stringify(ret) }],
+    };
+};
+export function createTool(server) {
+    server.tool(TOOL_NAME, TOOL_DESCRIPTION, TOOL_ARGS, TOOL_HANDLER);
 }

package/dist/tools/count-tool.js

@@ -0,0 +1,25 @@
+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, 
+      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."),
+    }, async ({ uuids }) => {
+        try {
+            logger.info("Counting UUIDs", uuids);
+            return {
+                content: [{ type: "text", text: `Count: ${uuids.length}` }],
+            };
+        }
+        catch (e) {
+            const errorMessage = e instanceof Error ? e.message : `Unknown error: ${e}`;
+            return {
+                content: [{ type: "text", text: `Error counting UUIDs: ${errorMessage}` }],
+            };
+        }
+    });
+}

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

@@ -0,0 +1,214 @@
+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 { postApi } from "../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.
+
+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.
+
+Uses elicitation forms for rich user interaction.
+`;
+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)"),
+    // Step 2: Schedule configuration
+    policyUuid: z.string().describe("Policy UUID (for configuring schedules)"),
+    scheduleConfigs: z.string().describe("JSON string of schedule configurations"),
+    // Step 3: Camera assignment
+    cameraUuids: z.string().describe("Comma-separated camera UUIDs to assign policy to"),
+    policyName: z.string().describe("Policy name (for reference)"),
+};
+const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+const TOOL_HANDLER = async (args, extra) => {
+    const { name, description, orgUuid, policyUuid, scheduleConfigs, cameraUuids, policyName } = args;
+    // Step 3: Camera assignment (if cameraUuids provided)
+    if (cameraUuids?.trim()) {
+        try {
+            const cameraList = cameraUuids
+                .split(",")
+                .map((uuid) => uuid.trim())
+                .filter((uuid) => uuid);
+            if (cameraList.length > 0) {
+                const cameraPayload = {
+                    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,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Failed to assign policy to cameras: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    }
+    // Step 2: Schedule configuration (if scheduleConfigs provided and non-empty)
+    if (scheduleConfigs?.trim() && scheduleConfigs.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,
+                };
+            }
+            // If configs.length === 0, fall through to policy creation
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error configuring schedules: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    }
+    // Step 1: Policy creation (if name provided)
+    if (name?.trim()) {
+        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 {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to create camera policy: ${result.errorMsg || "Unknown error"}`,
+                        },
+                    ],
+                };
+            }
+            console.error(`[createCameraPolicyTool] -- Proceeding with schedule-trigger-configuration form. Got result ${JSON.stringify(result)}`);
+            // Success - now show schedule configuration form
+            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",
+                policyUuid: result.policyUuid,
+                policyName: name,
+            };
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify(jsonResultResponse),
+                    },
+                ],
+                structuredContent: jsonResultResponse,
+            };
+        }
+        catch (error) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error creating camera policy: ${error instanceof Error ? error.message : "Unknown error"}`,
+                    },
+                ],
+            };
+        }
+    }
+    // Step 0: Show initial form (no args provided)
+    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",
+                }),
+            },
+        ],
+    };
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}