neuron-mcp-server 1.0.0 → 1.1.0

package/src/tools/profile-privacy.ts

@@ -0,0 +1,215 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+export function registerProfilePrivacyTools(server: McpServer): void {
+  // 1. Update Profile Name
+  server.registerTool(
+    "neuron_update_profile_name",
+    {
+      title: "Update Profile Name",
+      description: "Update the bot's WhatsApp display name on the given channel.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        name: z.string().min(1).describe("New display name"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("PUT", `/whatsapp-actions/${args.channelId}/profile/name`, {
+          name: args.name,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 2. Update Profile Picture
+  server.registerTool(
+    "neuron_update_profile_picture",
+    {
+      title: "Update Profile Picture",
+      description: "Update the bot's WhatsApp profile picture from an image URL.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        imageUrl: z.string().url().describe("URL of the image to set as profile picture"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("PUT", `/whatsapp-actions/${args.channelId}/profile/picture`, {
+          imageUrl: args.imageUrl,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 3. Remove Profile Picture
+  server.registerTool(
+    "neuron_remove_profile_picture",
+    {
+      title: "Remove Profile Picture",
+      description: "Remove the bot's WhatsApp profile picture, reverting to the default.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("DELETE", `/whatsapp-actions/${args.channelId}/profile/picture`);
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 4. Update Profile Status
+  server.registerTool(
+    "neuron_update_profile_status",
+    {
+      title: "Update Profile Status",
+      description: "Update the bot's WhatsApp status/bio text.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        status: z.string().min(1).describe("New status/bio text"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("PUT", `/whatsapp-actions/${args.channelId}/profile/status`, {
+          status: args.status,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 5. Get Privacy Settings
+  server.registerTool(
+    "neuron_get_privacy_settings",
+    {
+      title: "Get Privacy Settings",
+      description: "Fetch the bot's current WhatsApp privacy settings (last seen, online, profile picture, status, read receipts, groups add).",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+      }),
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("GET", `/whatsapp-actions/${args.channelId}/privacy`);
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 6. Update Privacy Setting
+  server.registerTool(
+    "neuron_update_privacy_setting",
+    {
+      title: "Update Privacy Setting",
+      description: "Update a specific WhatsApp privacy setting. Settings: lastSeen (all/contacts/contact_blacklist/none), online (all/match_last_seen), profilePicture (all/contacts/contact_blacklist/none), status (all/contacts/contact_blacklist/none), readReceipts (all/none), groupsAdd (all/contacts/contact_blacklist).",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        setting: z.enum(["lastSeen", "online", "profilePicture", "status", "readReceipts", "groupsAdd"]).describe("Privacy setting to update"),
+        value: z.string().min(1).describe("New value for the setting (see description for allowed values per setting)"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("PUT", `/whatsapp-actions/${args.channelId}/privacy/${args.setting}`, {
+          value: args.value,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 7. Block Contact
+  server.registerTool(
+    "neuron_block_contact",
+    {
+      title: "Block Contact",
+      description: "Block a WhatsApp contact. Blocked contacts cannot message the bot or see its profile.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        jid: z.string().describe("Contact JID or phone number to block (e.g. '2348012345678' or '2348012345678@s.whatsapp.net')"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("POST", `/whatsapp-actions/${args.channelId}/block`, {
+          jid: args.jid,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 8. Unblock Contact
+  server.registerTool(
+    "neuron_unblock_contact",
+    {
+      title: "Unblock Contact",
+      description: "Unblock a previously blocked WhatsApp contact.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        jid: z.string().describe("Contact JID or phone number to unblock"),
+      }),
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("POST", `/whatsapp-actions/${args.channelId}/unblock`, {
+          jid: args.jid,
+        });
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 9. Get Blocklist
+  server.registerTool(
+    "neuron_get_blocklist",
+    {
+      title: "Get Blocklist",
+      description: "Fetch the list of all blocked WhatsApp contacts for the bot on the given channel.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+      }),
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("GET", `/whatsapp-actions/${args.channelId}/blocklist`);
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+
+  // 10. Get Business Profile
+  server.registerTool(
+    "neuron_get_business_profile",
+    {
+      title: "Get Business Profile",
+      description: "Fetch the WhatsApp Business profile of an external contact, including description, website, category, and business hours.",
+      inputSchema: z.object({
+        channelId: z.string().describe("WhatsApp channel identifier (UUID)"),
+        jid: z.string().describe("Contact JID or phone number to look up (e.g. '2348012345678' or '2348012345678@s.whatsapp.net')"),
+      }),
+      annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    },
+    async (args) => {
+      try {
+        const res = await api("GET", `/whatsapp-actions/${args.channelId}/business-profile/${args.jid}`);
+        return jsonResult(res);
+      } catch (error) { return errorResult(error); }
+    },
+  );
+}

package/src/tools/reflections.ts

@@ -0,0 +1,124 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+/**
+ * Register reflection tools (bot self-learning reflections)
+ */
+export function registerReflectionsTools(server: McpServer): void {
+  // 1. List Reflections
+  server.registerTool(
+    "neuron_list_reflections",
+    {
+      title: "List Reflections",
+      description: "Retrieve pending reflections that the bot has generated from conversations, awaiting human review. Optionally filter by approval status.",
+      inputSchema: z.object({
+        botId: z.string().describe("Unique identifier (UUID) of the bot to list reflections for"),
+        status: z.enum(["pending", "approved", "rejected"]).optional().describe("Filter reflections by approval status (default: all statuses)"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const { botId, status } = args;
+      const params: Record<string, string> = {};
+
+      if (status !== undefined) {
+        params.status = status;
+      }
+
+      const response = await api("GET", `/reflections/bot/${botId}`, undefined, params);
+
+      if (response.success) {
+        return jsonResult(response.data);
+      } else {
+        return errorResult(response.error || "Failed to list reflections");
+      }
+    }
+  );
+
+  // 2. Approve Reflection
+  server.registerTool(
+    "neuron_approve_reflection",
+    {
+      title: "Approve Reflection",
+      description: "Approve a bot-generated reflection to incorporate the learned insight into the bot's future behavior and responses.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the reflection to approve"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const response = await api("PUT", `/reflections/${args.id}/approve`);
+
+      if (response.success) {
+        return jsonResult(response.data || { message: "Reflection approved successfully" });
+      } else {
+        return errorResult(response.error || "Failed to approve reflection");
+      }
+    }
+  );
+
+  // 3. Reject Reflection
+  server.registerTool(
+    "neuron_reject_reflection",
+    {
+      title: "Reject Reflection",
+      description: "Reject a bot-generated reflection to prevent it from being incorporated into the bot's learned behavior.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the reflection to reject"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const response = await api("PUT", `/reflections/${args.id}/reject`);
+
+      if (response.success) {
+        return jsonResult(response.data || { message: "Reflection rejected successfully" });
+      } else {
+        return errorResult(response.error || "Failed to reject reflection");
+      }
+    }
+  );
+
+  // 4. Sync Reflections
+  server.registerTool(
+    "neuron_sync_reflections",
+    {
+      title: "Sync Reflections",
+      description: "Synchronize all approved reflections into the bot's active knowledge base, applying learned insights to future conversations.",
+      inputSchema: z.object({
+        botId: z.string().describe("Unique identifier (UUID) of the bot to sync reflections for"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (args) => {
+      const response = await api("POST", `/reflections/bot/${args.botId}/sync`);
+
+      if (response.success) {
+        return jsonResult(response.data || { message: "Reflections synced successfully" });
+      } else {
+        return errorResult(response.error || "Failed to sync reflections");
+      }
+    }
+  );
+}

package/src/tools/scheduled-messages.ts

@@ -0,0 +1,144 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+export function registerScheduledMessageTools(server: McpServer): void {
+  // List scheduled messages
+  server.registerTool(
+    "neuron_list_scheduled_messages",
+    {
+      title: "List Scheduled Messages",
+      description:
+        "Retrieve a paginated list of scheduled messages for the current organization, with optional filtering by status (scheduled, sent, failed, cancelled).",
+      inputSchema: z.object({
+        status: z
+          .string()
+          .optional()
+          .describe("Filter by status: 'scheduled', 'sent', 'failed', or 'cancelled'"),
+        page: z
+          .number()
+          .int()
+          .positive()
+          .optional()
+          .describe("Page number for pagination (default: 1)"),
+        limit: z
+          .number()
+          .int()
+          .positive()
+          .optional()
+          .describe("Number of items per page (default: 20)"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", "/scheduled-messages", undefined, {
+          status: params.status,
+          page: params.page,
+          limit: params.limit,
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  // Get a scheduled message
+  server.registerTool(
+    "neuron_get_scheduled_message",
+    {
+      title: "Get Scheduled Message",
+      description:
+        "Retrieve detailed information about a specific scheduled message, including its status, send time, and message content.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the scheduled message"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `/scheduled-messages/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  // Update a scheduled message
+  server.registerTool(
+    "neuron_update_scheduled_message",
+    {
+      title: "Update Scheduled Message",
+      description:
+        "Update the message content, media, or send time of a scheduled message. Only messages with status 'scheduled' can be updated.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the scheduled message to update"),
+        message: z.string().optional().describe("New message text content"),
+        messageType: z
+          .string()
+          .optional()
+          .describe("New message type: 'text', 'image', 'audio', 'video', or 'document'"),
+        mediaUrl: z.string().optional().describe("New media URL to attach"),
+        contactName: z.string().optional().describe("Updated display name for the recipient"),
+        sendAt: z
+          .string()
+          .optional()
+          .describe("New ISO 8601 date-time for scheduled delivery (must be in the future)"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const { id, ...body } = params;
+        const result = await api("PUT", `/scheduled-messages/${id}`, body);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+
+  // Cancel a scheduled message
+  server.registerTool(
+    "neuron_cancel_scheduled_message",
+    {
+      title: "Cancel Scheduled Message",
+      description:
+        "Cancel a scheduled message to prevent it from being sent. Only messages with status 'scheduled' can be cancelled. This action cannot be undone.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the scheduled message to cancel"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("DELETE", `/scheduled-messages/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    },
+  );
+}