rhombus-node-mcp 0.1.32 → 0.1.33

package/dist/api/automated-prompts-tool-api.js

@@ -0,0 +1,195 @@
+import { postApi } from "../network/network.js";
+import { ChatFollowUpActionEnum, } from "../types/automated-prompts-tool-types.js";
+import { formatIsoWithOffset } from "../util.js";
+function extractNotifyUserUuids(followUpActions) {
+    if (!followUpActions)
+        return undefined;
+    const notifyAction = followUpActions.find((action) => action?.type === ChatFollowUpActionEnum.NOTIFY_USERS);
+    if (!notifyAction)
+        return undefined;
+    const userUuids = notifyAction.userUuids;
+    return userUuids?.filter((u) => u !== null) ?? [];
+}
+function toSummary(prompt, timeZone) {
+    if (!prompt)
+        return undefined;
+    return {
+        uuid: prompt.uuid ?? undefined,
+        prompt: prompt.prompt ?? undefined,
+        responseTemplate: prompt.responseTemplate ?? undefined,
+        frequency: prompt.frequency
+            ? {
+                frequency: prompt.frequency.frequency ?? undefined,
+                unit: prompt.frequency.unit ?? undefined,
+            }
+            : undefined,
+        invokeAt: formatIsoWithOffset(prompt.invokeAtMs, timeZone),
+        permissionGroupUuid: prompt.permissionGroupUuid ?? undefined,
+        notifyUserUuids: extractNotifyUserUuids(prompt.followUpActions),
+        scheduleUuid: prompt.scheduleUuid ?? undefined,
+        orgUuid: prompt.orgUuid ?? undefined,
+    };
+}
+function toHistoryEntry(record, timeZone) {
+    if (!record)
+        return undefined;
+    return {
+        uuid: record.uuid ?? undefined,
+        automatedPromptUuid: record.automatedPromptUuid ?? undefined,
+        query: record.query ?? undefined,
+        response: record.response ?? undefined,
+        queriedAt: formatIsoWithOffset(record.queriedAtMs, timeZone),
+        respondedAt: formatIsoWithOffset(record.respondedAtMs, timeZone),
+        responseType: record.responseType ?? undefined,
+    };
+}
+function buildSettingsBody(input, includeUuid) {
+    const settings = {};
+    if (includeUuid && "promptUuid" in input && input.promptUuid) {
+        settings.uuid = input.promptUuid;
+    }
+    if (input.prompt !== undefined && input.prompt !== null) {
+        settings.prompt = input.prompt;
+    }
+    if (input.responseTemplate !== undefined && input.responseTemplate !== null) {
+        settings.responseTemplate = input.responseTemplate;
+    }
+    if (input.invokeAtMs !== undefined && input.invokeAtMs !== null) {
+        settings.invokeAtMs = input.invokeAtMs;
+    }
+    if (input.frequencyValue !== undefined &&
+        input.frequencyValue !== null &&
+        input.frequencyUnit !== undefined &&
+        input.frequencyUnit !== null) {
+        settings.frequency = {
+            frequency: input.frequencyValue,
+            unit: input.frequencyUnit,
+        };
+    }
+    if (input.permissionGroupUuid !== undefined && input.permissionGroupUuid !== null) {
+        settings.permissionGroupUuid = input.permissionGroupUuid;
+    }
+    if (input.notifyUserUuids !== undefined && input.notifyUserUuids !== null) {
+        settings.followUpActions = input.notifyUserUuids.length
+            ? [
+                {
+                    type: ChatFollowUpActionEnum.NOTIFY_USERS,
+                    userUuids: input.notifyUserUuids,
+                },
+            ]
+            : [];
+    }
+    return settings;
+}
+export async function listAutomatedPrompts(pageRequest, requestModifiers, sessionId, timeZone) {
+    const res = await postApi({
+        route: "/chatbot/automation/getAutomatedPromptsForOrg",
+        body: pageRequest,
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    const settingsList = (res.settingsList ?? [])
+        .map((p) => toSummary(p, timeZone))
+        .filter((s) => s !== undefined);
+    return {
+        settingsList,
+        lastEvaluatedKey: res.lastEvaluatedKey ?? undefined,
+    };
+}
+export async function getAutomatedPrompt(promptUuid, requestModifiers, sessionId, timeZone) {
+    const res = await postApi({
+        route: "/chatbot/automation/getAutomatedPrompt",
+        body: { promptUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return toSummary(res.settings, timeZone);
+}
+export async function createAutomatedPrompt(input, requestModifiers, sessionId, timeZone) {
+    const settings = buildSettingsBody(input, /*includeUuid*/ false);
+    const res = await postApi({
+        route: "/chatbot/automation/createAutomatedPrompt",
+        body: { settings },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return toSummary(res.settings, timeZone);
+}
+export async function updateAutomatedPrompt(input, requestModifiers, sessionId, timeZone) {
+    const selectiveUpdate = buildSettingsBody(input, /*includeUuid*/ true);
+    const res = await postApi({
+        route: "/chatbot/automation/updateAutomatedPrompt",
+        body: { selectiveUpdate },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return toSummary(res.settings, timeZone);
+}
+export async function deleteAutomatedPrompt(promptUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/chatbot/automation/deleteAutomatedPrompt",
+        body: { promptUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { ok: true, action: "deleted" };
+}
+export async function getAutomatedPromptChatHistory(promptUuid, pageRequest, requestModifiers, sessionId, timeZone) {
+    const res = await postApi({
+        route: "/chatbot/automation/getAutomatedPromptChatHistory",
+        body: {
+            promptUuid,
+            lastEvaluatedKey: pageRequest.lastEvaluatedKey ?? undefined,
+            maxPageSize: pageRequest.maxPageSize ?? undefined,
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    const chatHistory = (res.chatHistory ?? [])
+        .map((r) => toHistoryEntry(r, timeZone))
+        .filter((e) => e !== undefined);
+    return {
+        chatHistory,
+        lastEvaluatedKey: res.lastEvaluatedKey ?? undefined,
+    };
+}
+export async function shareAutomatedPromptResponse(chatUuid, visibility, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/chatbot/automation/shareAutomatedPromptResponse",
+        body: {
+            chatUuid,
+            privacy: { visibility },
+        },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return { ok: true, action: `visibility set to ${visibility}` };
+}
+export async function verifyJobScheduled(promptUuid, requestModifiers, sessionId) {
+    const res = await postApi({
+        route: "/chatbot/automation/verifyJobScheduled",
+        body: { promptUuid },
+        modifiers: requestModifiers,
+        sessionId,
+    });
+    if (res.error)
+        throw new Error(JSON.stringify(res));
+    return {
+        scheduleExpression: res.scheduleExpression ?? undefined,
+        scheduleTimezone: res.scheduleTimezone ?? undefined,
+    };
+}

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

@@ -58,6 +58,39 @@ export async function getPermissionsForCurrentUser(requestModifiers, sessionId)
             : undefined,
     };
 }
+/**
+ * Keep only non-null string entries from a nullable string[] coming back from
+ * the generated schema types.
+ */
+function cleanStringArray(arr) {
+    if (!arr)
+        return undefined;
+    const cleaned = arr.filter((v) => typeof v === "string");
+    return cleaned.length > 0 ? cleaned : undefined;
+}
+/**
+ * Map a `{ [k]: PermissionEnum }` to a `Record<string, string>` dropping null
+ * values. Returns undefined when the input is nullish so the field is omitted
+ * from the JSON payload entirely (and the filtering proxy's `includeFields`
+ * can omit it without ambiguity).
+ */
+function toStringMap(map) {
+    if (!map)
+        return undefined;
+    const entries = Object.entries(map).filter((pair) => typeof pair[1] === "string");
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function toNestedStringMap(map) {
+    if (!map)
+        return undefined;
+    const result = {};
+    for (const [outer, inner] of Object.entries(map)) {
+        const cleanedInner = toStringMap(inner);
+        if (cleanedInner)
+            result[outer] = cleanedInner;
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
 export async function getPermissionGroups(requestModifiers, sessionId) {
     const res = await postApi({
         route: "/permission/getPermissionGroupsForOrg",
@@ -71,7 +104,23 @@ export async function getPermissionGroups(requestModifiers, sessionId) {
     return (res.permissionGroups?.map(group => ({
         uuid: group.uuid ?? undefined,
         name: group.name ?? undefined,
+        description: group.description ?? undefined,
         orgUuid: group.orgUuid ?? undefined,
-        role: group.role ?? undefined,
+        mutable: group.mutable ?? undefined,
+        superAdmin: group.superAdmin ?? undefined,
+        installer: group.installer ?? undefined,
+        inLine: group.inLine ?? undefined,
+        storedInS3: group.storedInS3 ?? undefined,
+        defaultPermissionForNewLocations: group.defaultPermissionForNewLocations ?? undefined,
+        defaultAccessControlPermissionForNewLocations: group.defaultAccessControlPermissionForNewLocations ?? undefined,
+        functionalityList: group.functionalityList ?? undefined,
+        accessibleLocations: cleanStringArray(group.accessibleLocations),
+        assignablePermissionGroups: cleanStringArray(group.assignablePermissionGroups),
+        // Heavy maps — callers should typically prune these out via includeFields.
+        locationAccessMap: toStringMap(group.locationAccessMap),
+        accessControlLocationAccessMap: toStringMap(group.accessControlLocationAccessMap),
+        deviceAccessMap: toStringMap(group.deviceAccessMap),
+        userPermissionGroupAccessMap: toStringMap(group.userPermissionGroupAccessMap),
+        locationGranularAccessMap: toNestedStringMap(group.locationGranularAccessMap),
     })) ?? []);
 }

package/dist/tools/automated-prompts-tool.js

@@ -0,0 +1,145 @@
+import { createAutomatedPrompt, deleteAutomatedPrompt, getAutomatedPrompt, getAutomatedPromptChatHistory, listAutomatedPrompts, shareAutomatedPromptResponse, updateAutomatedPrompt, verifyJobScheduled, } from "../api/automated-prompts-tool-api.js";
+import { AutomatedPromptsRequestType, CreateRequestSchema, DeleteRequestSchema, GetHistoryRequestSchema, GetRequestSchema, ListRequestSchema, OUTPUT_SCHEMA, ShareResponseRequestSchema, TOOL_ARGS, UpdateRequestSchema, VerifyScheduledRequestSchema, } from "../types/automated-prompts-tool-types.js";
+import { createToolStructuredContent, createToolTextContent, extractFromToolExtra, } from "../util.js";
+const TOOL_NAME = "automated-prompts-tool";
+const TOOL_DESCRIPTION = `
+This tool manages Rhombus MIND automated prompts - scheduled chatbot jobs that run a prompt at a recurring interval and store each response. Use it to list, inspect, create, update, delete, page through past responses for, share, or re-verify the schedule of an automated prompt.
+
+Modes (set "requestType"):
+- ${AutomatedPromptsRequestType.LIST}: List all automated prompts in the org. Optional 'lastEvaluatedKey' / 'maxPageSize' for pagination.
+- ${AutomatedPromptsRequestType.GET}: Get a single automated prompt's settings. Requires 'promptUuid'.
+- ${AutomatedPromptsRequestType.CREATE}: Create a new automated prompt. Requires 'prompt', 'invokeAt' (ISO 8601 with offset, must be at least 15 minutes in the future), 'frequencyValue', 'frequencyUnit', and 'permissionGroupUuid'. Optional 'responseTemplate' and 'notifyUserUuids'.
+- ${AutomatedPromptsRequestType.UPDATE}: Selectively update an automated prompt. Requires 'promptUuid'; only the fields you set will be changed. To change the role, the caller must have access to both the current and new role. Pass an empty 'notifyUserUuids' array to clear notifyees.
+- ${AutomatedPromptsRequestType.DELETE}: Delete an automated prompt and all of its stored responses. Requires 'promptUuid'.
+- ${AutomatedPromptsRequestType.GET_HISTORY}: Page through responses generated by an automated prompt. Requires 'promptUuid'. Optional 'lastEvaluatedKey' / 'maxPageSize'.
+- ${AutomatedPromptsRequestType.SHARE_RESPONSE}: Update the visibility of one stored response. Requires 'chatUuid' and 'visibility' (PUBLIC, ORG_WIDE, SELECT_USERS, PRIVATE).
+- ${AutomatedPromptsRequestType.VERIFY_SCHEDULED}: Re-verify that the job is scheduled to trigger; the server reschedules it if missing. Requires 'promptUuid'.
+
+Notes:
+- Use 'user-tool' to look up user UUIDs and resolve them to names/emails. 'notifyUserUuids' must be members of the chosen 'permissionGroupUuid'.
+- 'invokeAt' is an ISO 8601 timestamp; both 'Z' and '+/-HH:mm' offsets are accepted. The tool converts it to milliseconds for the API.
+- Timestamps in the output are ISO 8601 strings with timezone offset (defaults to America/Los_Angeles when no org timezone is available).
+- 'submitTestPrompt' is intentionally not exposed by this tool.
+`;
+function formatZodError(err) {
+    return err.issues
+        .map(issue => {
+        const path = issue.path.join(".");
+        return path ? `${path}: ${issue.message}` : issue.message;
+    })
+        .join("; ");
+}
+function validationErrorResponse(err) {
+    return createToolTextContent(JSON.stringify({ error: formatZodError(err) }));
+}
+const TOOL_HANDLER = async (args, _extra) => {
+    const { requestModifiers, sessionId } = extractFromToolExtra(_extra);
+    try {
+        switch (args.requestType) {
+            case AutomatedPromptsRequestType.LIST: {
+                const parsed = ListRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const { lastEvaluatedKey, maxPageSize } = parsed.data;
+                const result = await listAutomatedPrompts({
+                    lastEvaluatedKey: lastEvaluatedKey ?? undefined,
+                    maxPageSize: maxPageSize ?? undefined,
+                }, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    settingsList: result.settingsList,
+                    lastEvaluatedKey: result.lastEvaluatedKey,
+                });
+            }
+            case AutomatedPromptsRequestType.GET: {
+                const parsed = GetRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const settings = await getAutomatedPrompt(parsed.data.promptUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ settings });
+            }
+            case AutomatedPromptsRequestType.CREATE: {
+                const parsed = CreateRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const data = parsed.data;
+                const settings = await createAutomatedPrompt({
+                    prompt: data.prompt,
+                    invokeAtMs: new Date(data.invokeAt).getTime(),
+                    frequencyValue: data.frequencyValue,
+                    frequencyUnit: data.frequencyUnit,
+                    permissionGroupUuid: data.permissionGroupUuid,
+                    responseTemplate: data.responseTemplate ?? undefined,
+                    notifyUserUuids: data.notifyUserUuids ?? undefined,
+                }, requestModifiers, sessionId);
+                return createToolStructuredContent({ settings });
+            }
+            case AutomatedPromptsRequestType.UPDATE: {
+                const parsed = UpdateRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const data = parsed.data;
+                const settings = await updateAutomatedPrompt({
+                    promptUuid: data.promptUuid,
+                    prompt: data.prompt ?? undefined,
+                    invokeAtMs: data.invokeAt ? new Date(data.invokeAt).getTime() : undefined,
+                    frequencyValue: data.frequencyValue ?? undefined,
+                    frequencyUnit: data.frequencyUnit ?? undefined,
+                    permissionGroupUuid: data.permissionGroupUuid ?? undefined,
+                    responseTemplate: data.responseTemplate ?? undefined,
+                    notifyUserUuids: data.notifyUserUuids ?? undefined,
+                }, requestModifiers, sessionId);
+                return createToolStructuredContent({ settings });
+            }
+            case AutomatedPromptsRequestType.DELETE: {
+                const parsed = DeleteRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const success = await deleteAutomatedPrompt(parsed.data.promptUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ success });
+            }
+            case AutomatedPromptsRequestType.GET_HISTORY: {
+                const parsed = GetHistoryRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const data = parsed.data;
+                const result = await getAutomatedPromptChatHistory(data.promptUuid, {
+                    lastEvaluatedKey: data.lastEvaluatedKey ?? undefined,
+                    maxPageSize: data.maxPageSize ?? undefined,
+                }, requestModifiers, sessionId);
+                return createToolStructuredContent({
+                    chatHistory: result.chatHistory,
+                    lastEvaluatedKey: result.lastEvaluatedKey,
+                });
+            }
+            case AutomatedPromptsRequestType.SHARE_RESPONSE: {
+                const parsed = ShareResponseRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const { chatUuid, visibility } = parsed.data;
+                const success = await shareAutomatedPromptResponse(chatUuid, visibility, requestModifiers, sessionId);
+                return createToolStructuredContent({ success });
+            }
+            case AutomatedPromptsRequestType.VERIFY_SCHEDULED: {
+                const parsed = VerifyScheduledRequestSchema.safeParse(args);
+                if (!parsed.success)
+                    return validationErrorResponse(parsed.error);
+                const verifyResult = await verifyJobScheduled(parsed.data.promptUuid, requestModifiers, sessionId);
+                return createToolStructuredContent({ verifyResult });
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return createToolStructuredContent({ error: error.message });
+        }
+        return createToolStructuredContent({ error: "Unknown error" });
+    }
+    return createToolStructuredContent({ error: "Invalid request type" });
+};
+export function createTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: TOOL_DESCRIPTION,
+        inputSchema: TOOL_ARGS,
+        outputSchema: OUTPUT_SCHEMA.shape,
+    }, TOOL_HANDLER);
+}

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

@@ -2,7 +2,7 @@ import { getOrg } from "../api/get-org-information-tool-api.js";
 import { TOOL_ARGS } from "../types/get-org-information-tool-types.js";
 const TOOL_NAME = "get-org-information";
 const TOOL_DESCRIPTION = "Get general information about the organization including org name, camera configuration defaults, contact information, and org settings.";
-const TOOL_HANDLER = async (args, extra) => {
+const TOOL_HANDLER = async (_, extra) => {
     const org = await getOrg(extra._meta?.requestModifiers, extra.sessionId);
     return {
         content: [

package/dist/tools/user-tool.js

@@ -9,9 +9,16 @@ It has the following modes of operation, determined by the "requestType" paramet
 - ${UserToolRequestType.LIST_USERS}: List all users in the organization with their details and roles.
 - ${UserToolRequestType.FIND_BY_EMAIL}: Find a specific user by their email address. Requires the email parameter.
 - ${UserToolRequestType.GET_PERMISSIONS}: Get the permissions for the current API user/token.
-- ${UserToolRequestType.GET_PERMISSION_GROUPS}: List all permission groups defined in the organization.
+- ${UserToolRequestType.GET_PERMISSION_GROUPS}: List all permission groups defined in the organization. Each row can be very large — see below.
 
 User UUIDs returned here can be used with the access-control-tool to look up credentials.
+
+IMPORTANT for '${UserToolRequestType.GET_PERMISSION_GROUPS}':
+Each permission group row includes five access maps whose size scales with the org's locations, devices, and other permission groups. The total payload for 'userPermissionGroupAccessMap' across all rows grows O(N^2) in the number of permission groups. Before calling, decide which fields you actually need and pass them via 'includeFields':
+- Safe/small fields (O(1) per row): 'permissionGroups.uuid', 'permissionGroups.name', 'permissionGroups.description', 'permissionGroups.mutable', 'permissionGroups.superAdmin', 'permissionGroups.installer', 'permissionGroups.defaultPermissionForNewLocations', 'permissionGroups.defaultAccessControlPermissionForNewLocations'.
+- Bounded fields (O(K) per row): 'permissionGroups.functionalityList', 'permissionGroups.accessibleLocations', 'permissionGroups.assignablePermissionGroups'.
+- Heavy fields (O(locations) / O(devices) / O(groups) per row): 'permissionGroups.locationAccessMap', 'permissionGroups.accessControlLocationAccessMap', 'permissionGroups.deviceAccessMap', 'permissionGroups.userPermissionGroupAccessMap', 'permissionGroups.locationGranularAccessMap'. Only request these when you specifically need them for a user.
+Typical usage when just picking a role uuid: 'includeFields: ["permissionGroups.uuid", "permissionGroups.name", "permissionGroups.description"]'.
 `;
 const TOOL_HANDLER = async (args, _extra) => {
     const { requestModifiers, sessionId } = extractFromToolExtra(_extra);

package/dist/types/automated-prompts-tool-types.js

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { ISOTimestampFormatDescription } from "../utils/timestampInput.js";
+import { ChatFollowUpActionEnum, ChatVisibilityEnum, FrequencyUnitEnum } from "./schema.js";
+export var AutomatedPromptsRequestType;
+(function (AutomatedPromptsRequestType) {
+    AutomatedPromptsRequestType["LIST"] = "list";
+    AutomatedPromptsRequestType["GET"] = "get";
+    AutomatedPromptsRequestType["CREATE"] = "create";
+    AutomatedPromptsRequestType["UPDATE"] = "update";
+    AutomatedPromptsRequestType["DELETE"] = "delete";
+    AutomatedPromptsRequestType["GET_HISTORY"] = "get-history";
+    AutomatedPromptsRequestType["SHARE_RESPONSE"] = "share-response";
+    AutomatedPromptsRequestType["VERIFY_SCHEDULED"] = "verify-scheduled";
+})(AutomatedPromptsRequestType || (AutomatedPromptsRequestType = {}));
+export const TOOL_ARGS = {
+    requestType: z
+        .enum(AutomatedPromptsRequestType)
+        .describe("The type of automated prompt request to make."),
+    promptUuid: z
+        .string()
+        .nullable()
+        .describe("UUID of the automated prompt. Required for 'get', 'update', 'delete', 'get-history', and 'verify-scheduled'."),
+    chatUuid: z
+        .string()
+        .nullable()
+        .describe("UUID of a chat record (an individual response generated by an automated prompt). Required for 'share-response'."),
+    visibility: z
+        .enum(ChatVisibilityEnum)
+        .nullable()
+        .describe("Visibility for a shared chat response. Required for 'share-response'. One of PUBLIC, ORG_WIDE, SELECT_USERS, PRIVATE."),
+    prompt: z
+        .string()
+        .nullable()
+        .describe("The prompt MIND will execute every time the job runs. Required for 'create', recommended for 'update'."),
+    responseTemplate: z
+        .string()
+        .nullable()
+        .describe("Optional template that guides the shape of MIND's response. Used by 'create' and 'update'."),
+    frequencyValue: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .describe("How many time units between runs (e.g. 1 for 'every 1 day'). Required for 'create' alongside frequencyUnit."),
+    frequencyUnit: z
+        .enum(FrequencyUnitEnum)
+        .nullable()
+        .describe("Unit for the recurrence (HOURS, DAYS, WEEKS, MONTHS). Required for 'create' alongside frequencyValue."),
+    invokeAt: z.iso
+        .datetime({
+        message: "Invalid datetime string. Expected ISO 8601 format.",
+        offset: true,
+    })
+        .nullable()
+        .describe("When the automated prompt should first run. Required for 'create'. Must be at least 15 minutes in the future. " +
+        ISOTimestampFormatDescription),
+    permissionGroupUuid: z
+        .string()
+        .nullable()
+        .describe("UUID of the permission group/role that owns the job. Users in this role (or a higher role) can view and edit the job, and MIND uses this role's permissions when running the prompt. Required for 'create'."),
+    notifyUserUuids: z
+        .array(z.string())
+        .nullable()
+        .describe("User UUIDs to email-notify when MIND finishes a run. These users must be members of the permission group set above. Used by 'create' and 'update'. Pass an empty array to clear existing notifyees on 'update'."),
+    lastEvaluatedKey: z
+        .string()
+        .nullable()
+        .describe("Pagination cursor returned by a previous 'list' or 'get-history' call. Pass to fetch the next page."),
+    maxPageSize: z
+        .number()
+        .int()
+        .positive()
+        .nullable()
+        .describe("Maximum number of items per page for 'list' and 'get-history'."),
+};
+const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+/**
+ * Below is the individual request types schema
+ */
+const invokeAtDatetime = z.iso.datetime({
+    message: "invokeAt must be a valid ISO 8601 timestamp with offset (e.g. 2026-04-22T10:57:00-07:00).",
+    offset: true,
+});
+export const ListRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.LIST),
+    lastEvaluatedKey: z.string().nullish(),
+    maxPageSize: z.number().int().positive().nullish(),
+});
+export const GetRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.GET),
+    promptUuid: z.string().min(1, "promptUuid is required."),
+});
+export const CreateRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.CREATE),
+    prompt: z.string().min(1, "prompt is required."),
+    invokeAt: invokeAtDatetime,
+    frequencyValue: z.number().int().positive(),
+    frequencyUnit: z.enum(FrequencyUnitEnum),
+    permissionGroupUuid: z.string().min(1, "permissionGroupUuid is required."),
+    responseTemplate: z.string().nullish(),
+    notifyUserUuids: z.array(z.string()).nullish(),
+});
+export const UpdateRequestSchema = z
+    .object({
+    requestType: z.literal(AutomatedPromptsRequestType.UPDATE),
+    promptUuid: z.string().min(1, "promptUuid is required."),
+    prompt: z.string().min(1).nullish(),
+    invokeAt: invokeAtDatetime.nullish(),
+    frequencyValue: z.number().int().positive().nullish(),
+    frequencyUnit: z.enum(FrequencyUnitEnum).nullish(),
+    permissionGroupUuid: z.string().min(1).nullish(),
+    responseTemplate: z.string().nullish(),
+    notifyUserUuids: z.array(z.string()).nullish(),
+})
+    .refine(data => (data.frequencyValue == null) === (data.frequencyUnit == null), {
+    message: "frequencyValue and frequencyUnit must be provided together when updating recurrence.",
+    path: ["frequencyValue"],
+});
+export const DeleteRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.DELETE),
+    promptUuid: z.string().min(1, "promptUuid is required."),
+});
+export const GetHistoryRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.GET_HISTORY),
+    promptUuid: z.string().min(1, "promptUuid is required."),
+    lastEvaluatedKey: z.string().nullish(),
+    maxPageSize: z.number().int().positive().nullish(),
+});
+export const ShareResponseRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.SHARE_RESPONSE),
+    chatUuid: z.string().min(1, "chatUuid is required."),
+    visibility: z.enum(ChatVisibilityEnum),
+});
+export const VerifyScheduledRequestSchema = z.object({
+    requestType: z.literal(AutomatedPromptsRequestType.VERIFY_SCHEDULED),
+    promptUuid: z.string().min(1, "promptUuid is required."),
+});
+/* More shared types */
+const FrequencySchema = z
+    .object({
+    frequency: z.number().optional(),
+    unit: z.enum(FrequencyUnitEnum).optional(),
+})
+    .describe("How often the prompt runs.");
+const AutomatedPromptSummarySchema = z
+    .object({
+    uuid: z.string().optional(),
+    prompt: z.string().optional(),
+    responseTemplate: z.string().optional(),
+    frequency: FrequencySchema.optional(),
+    invokeAt: z
+        .string()
+        .optional()
+        .describe("Next run time as an ISO 8601 string with timezone offset."),
+    permissionGroupUuid: z.string().optional(),
+    notifyUserUuids: z.array(z.string()).optional(),
+    scheduleUuid: z.string().optional(),
+    orgUuid: z.string().optional(),
+})
+    .describe("Summary of an automated prompt's settings.");
+const ChatHistoryEntrySchema = z
+    .object({
+    uuid: z.string().optional(),
+    automatedPromptUuid: z.string().optional(),
+    query: z.string().optional(),
+    response: z.string().optional(),
+    queriedAt: z
+        .string()
+        .optional()
+        .describe("When the run started, as an ISO 8601 string with offset."),
+    respondedAt: z
+        .string()
+        .optional()
+        .describe("When the response was generated, as an ISO 8601 string with offset."),
+    responseType: z.string().optional(),
+})
+    .describe("One MIND response generated by an automated prompt run.");
+export const OUTPUT_SCHEMA = z.object({
+    settings: AutomatedPromptSummarySchema.optional().describe("Returned by 'get', 'create', and 'update'."),
+    settingsList: z.array(AutomatedPromptSummarySchema).optional().describe("Returned by 'list'."),
+    lastEvaluatedKey: z
+        .string()
+        .optional()
+        .describe("Pagination cursor for the next page; absent when no more pages."),
+    chatHistory: z.array(ChatHistoryEntrySchema).optional().describe("Returned by 'get-history'."),
+    verifyResult: z
+        .object({
+        scheduleExpression: z.string().optional(),
+        scheduleTimezone: z.string().optional(),
+    })
+        .optional()
+        .describe("Returned by 'verify-scheduled'. Schedule expression and timezone for the next trigger."),
+    success: z
+        .object({
+        ok: z.boolean(),
+        action: z.string(),
+    })
+        .optional()
+        .describe("Returned by 'delete' and 'share-response'."),
+    error: z.string().optional().describe("An error message if the request failed."),
+});
+// Re-export for the api/tool layers so they can build ChatPrivacy follow-ups.
+export { ChatFollowUpActionEnum, ChatVisibilityEnum, FrequencyUnitEnum };

package/dist/types/user-tool-types.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { INCLUDE_FIELDS_ARG, FILTER_BY_ARG } from "../util.js";
 export var UserToolRequestType;
 (function (UserToolRequestType) {
     UserToolRequestType["LIST_USERS"] = "list-users";
@@ -7,16 +6,71 @@ export var UserToolRequestType;
     UserToolRequestType["GET_PERMISSIONS"] = "get-permissions";
     UserToolRequestType["GET_PERMISSION_GROUPS"] = "get-permission-groups";
 })(UserToolRequestType || (UserToolRequestType = {}));
+// NOTE: `includeFields` and `filterBy` are NOT declared here — the
+// `createFilteringProxy` wrapper automatically injects them into every tool's
+// inputSchema and post-processes the handler's output. Declaring them here
+// would be dead code (the proxy overwrites them).
 export const TOOL_ARGS = {
     requestType: z.nativeEnum(UserToolRequestType).describe("The type of user request to make."),
     email: z
         .string()
         .nullable()
         .describe("The email address of the user to find. Required for 'find-by-email'."),
-    includeFields: INCLUDE_FIELDS_ARG,
-    filterBy: FILTER_BY_ARG,
 };
 const TOOL_ARGS_SCHEMA = z.object(TOOL_ARGS);
+// Permission level assigned to a resource for a role. Typed loosely as string
+// because the upstream schema enum (READONLY/ADMIN/LIVEONLY) may grow.
+const PermissionEnumLoose = z.string();
+const PermissionGroupSchema = z
+    .object({
+    uuid: z.string().optional(),
+    name: z.string().optional(),
+    description: z.string().optional(),
+    orgUuid: z.string().optional(),
+    mutable: z.boolean().optional(),
+    superAdmin: z.boolean().optional(),
+    installer: z.boolean().optional(),
+    inLine: z.boolean().optional(),
+    storedInS3: z.boolean().optional(),
+    defaultPermissionForNewLocations: PermissionEnumLoose.optional(),
+    defaultAccessControlPermissionForNewLocations: PermissionEnumLoose.optional(),
+    functionalityList: z
+        .array(z.string())
+        .optional()
+        .describe("List of functionality flags this role unlocks."),
+    accessibleLocations: z
+        .array(z.string())
+        .optional()
+        .describe("UUIDs of locations this role has any access to."),
+    assignablePermissionGroups: z
+        .array(z.string())
+        .optional()
+        .describe("UUIDs of other permission groups a member of this role may assign to users."),
+    // The five maps below grow with the number of locations / devices /
+    // other permission groups in the org. For large orgs a single row can be
+    // hundreds of KB; use `includeFields` to request only the maps you need.
+    locationAccessMap: z
+        .record(z.string(), PermissionEnumLoose)
+        .optional()
+        .describe("locationUuid -> permission level. Size = O(#locations)."),
+    accessControlLocationAccessMap: z
+        .record(z.string(), PermissionEnumLoose)
+        .optional()
+        .describe("locationUuid -> access-control permission level. Size = O(#locations)."),
+    deviceAccessMap: z
+        .record(z.string(), PermissionEnumLoose)
+        .optional()
+        .describe("deviceUuid -> permission level. Size = O(#devices)."),
+    userPermissionGroupAccessMap: z
+        .record(z.string(), PermissionEnumLoose)
+        .optional()
+        .describe("otherPermissionGroupUuid -> permission level. Total payload across all rows is O(N^2) in the number of permission groups — trim with includeFields."),
+    locationGranularAccessMap: z
+        .record(z.string(), z.record(z.string(), PermissionEnumLoose))
+        .optional()
+        .describe("locationUuid -> (subResourceUuid -> permission level). Size = O(#locations * avg #sub-resources)."),
+})
+    .describe("A permission group (role) definition.");
 export const OUTPUT_SCHEMA = z.object({
     users: z
         .array(z.object({
@@ -49,13 +103,8 @@ export const OUTPUT_SCHEMA = z.object({
         .optional()
         .describe("Current user permissions"),
     permissionGroups: z
-        .array(z.object({
-        uuid: z.string().optional(),
-        name: z.string().optional(),
-        orgUuid: z.string().optional(),
-        role: z.string().optional(),
-    }))
+        .array(PermissionGroupSchema)
         .optional()
-        .describe("List of permission groups"),
+        .describe("List of permission groups in the organization."),
     error: z.string().optional().describe("An error message if the request failed."),
 });

package/dist/util.js

@@ -168,3 +168,21 @@ export function formatTimestamp(timestampMs, timeZone) {
         locale: "en-US",
     });
 }
+/**
+ * Formats a timestamp in milliseconds to an ISO 8601 string with timezone offset.
+ * Format: "2025-04-21T10:57:00.000-07:00"
+ *
+ * Use this when returning timestamps in tool output schemas so the offset is preserved
+ * (rather than the bare "Z" produced by Date.prototype.toISOString()).
+ *
+ * @param timestampMs - Timestamp in milliseconds
+ * @param timeZone - Optional IANA timezone string (defaults to "America/Los_Angeles")
+ * @returns ISO 8601 string with offset, or undefined if input is null/undefined
+ */
+export function formatIsoWithOffset(timestampMs, timeZone) {
+    if (timestampMs === null || timestampMs === undefined)
+        return undefined;
+    return (DateTime.fromMillis(timestampMs)
+        .setZone(timeZone || "America/Los_Angeles")
+        .toISO() ?? undefined);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rhombus-node-mcp",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "MCP server for Rhombus API",
   "keywords": [
     "ai",