neuron-mcp-server 1.0.0 → 1.1.0

package/src/tools/bots.ts

@@ -0,0 +1,320 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+export function registerBotTools(server: McpServer): void {
+  // Create Bot
+  server.registerTool(
+    "neuron_create_bot",
+    {
+      title: "Create Bot",
+      description: "Create a new AI bot with specified name, model, and behavior instructions. Returns the created bot object.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        name: z.string().describe("Display name for the bot"),
+        systemPrompt: z.string().describe("System prompt that defines the bot's behavior, personality, and response guidelines"),
+        assignment: z.string().optional().describe("One-sentence role definition for the bot (max 2000 chars)"),
+        responsibilities: z.array(z.string()).optional().describe("Array of responsibility descriptions defining what the bot handles"),
+        llmModel: z.string().optional().describe("OpenRouter model ID (e.g., 'google/gemini-2.5-flash-lite', 'openrouter/auto')"),
+        llmTemperature: z.number().min(0).max(2).optional().describe("Temperature parameter controlling response randomness (0 = deterministic, 2 = creative)"),
+        maxTokens: z.number().positive().optional().describe("Maximum number of tokens the bot can generate per response"),
+        escalationPrompt: z.string().optional().describe("Prompt template used when escalating to a human agent (max 5000 chars)"),
+        greetingMessage: z.string().optional().describe("Automatic greeting sent when a new conversation starts (max 2000 chars)"),
+        welcomeMessage: z.string().optional().describe("Welcome message sent to new members joining groups the bot manages. Setting this field activates the batched welcome feature — new members are accumulated over a window (default 60s) and welcomed in a single message with @mentions. Set to null to disable."),
+        fallbackMessage: z.string().optional().describe("Message sent when the bot cannot understand user input (max 2000 chars)"),
+        whatsappChannelId: z.string().optional().describe("Unique identifier (UUID) of the WhatsApp channel to associate with the bot"),
+        metadata: z.record(z.unknown()).optional().describe("Arbitrary metadata object stored with the bot. Known keys: 'communityExitFollowUp' (auto-DM users who leave watched groups — { enabled: boolean, groupJids: string[], message: string with {name} placeholder }), 'learningConfig' (self-learning from conversations — { enabled: boolean, folder: string, groupChats: string[], dmPhones: string[], useAdminPhones: boolean }), 'loadBalancing' (multi-channel round-robin — { enabled: boolean, strategy: string }), 'welcomeNewMembers' (fine-tune welcome behavior — { batchWindowSeconds: number, groupJids: string[] }). Additional custom keys are preserved as-is."),
+      }),
+    },
+    async (params) => {
+      try {
+        const { name, systemPrompt, ...rest } = params;
+        const result = await api("POST", "bots", { name, systemPrompt, ...rest });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // List Bots
+  server.registerTool(
+    "neuron_list_bots",
+    {
+      title: "List Bots",
+      description: "Retrieve all bots accessible to the current user, including their configurations and status.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({}),
+    },
+    async () => {
+      try {
+        const result = await api("GET", "bots");
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get Bot
+  server.registerTool(
+    "neuron_get_bot",
+    {
+      title: "Get Bot",
+      description: "Retrieve detailed information about a specific bot including its configuration, status, and associated resources.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `bots/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Update Bot
+  server.registerTool(
+    "neuron_update_bot",
+    {
+      title: "Update Bot",
+      description: "Update an existing bot's configuration. Only provided fields are modified; omitted fields remain unchanged.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot to update"),
+        name: z.string().optional().describe("New display name for the bot"),
+        systemPrompt: z.string().optional().describe("New system prompt defining the bot's behavior and personality"),
+        assignment: z.string().optional().describe("One-sentence role definition for the bot (max 2000 chars)"),
+        responsibilities: z.array(z.string()).optional().describe("Array of responsibility descriptions defining what the bot handles"),
+        llmModel: z.string().optional().describe("OpenRouter model ID (e.g., 'google/gemini-2.5-flash-lite', 'openrouter/auto')"),
+        llmTemperature: z.number().min(0).max(2).optional().describe("Temperature parameter controlling response randomness (0 = deterministic, 2 = creative)"),
+        maxTokens: z.number().positive().optional().describe("Maximum number of tokens the bot can generate per response"),
+        escalationPrompt: z.string().optional().describe("Prompt template used when escalating to a human agent (max 5000 chars)"),
+        greetingMessage: z.string().optional().describe("Automatic greeting sent when a new conversation starts (max 2000 chars)"),
+        welcomeMessage: z.string().optional().describe("Welcome message sent to new members joining groups the bot manages. Setting this field activates the batched welcome feature — new members are accumulated over a window (default 60s) and welcomed in a single message with @mentions. Set to null to disable."),
+        fallbackMessage: z.string().optional().describe("Message sent when the bot cannot understand user input (max 2000 chars)"),
+        whatsappChannelId: z.string().optional().describe("Unique identifier (UUID) of the WhatsApp channel to associate with the bot"),
+        metadata: z.record(z.unknown()).optional().describe("Arbitrary metadata object stored with the bot. Replaces the entire metadata field — include ALL existing keys you want to keep. Known keys: 'communityExitFollowUp' (auto-DM users who leave watched groups — { enabled: boolean, groupJids: string[], message: string with {name} placeholder }), 'learningConfig' (self-learning from conversations — { enabled: boolean, folder: string, groupChats: string[], dmPhones: string[], useAdminPhones: boolean }), 'loadBalancing' (multi-channel round-robin — { enabled: boolean, strategy: string }), 'welcomeNewMembers' (fine-tune welcome behavior — { batchWindowSeconds: number, groupJids: string[] }). Additional custom keys are preserved as-is."),
+      }),
+    },
+    async (params) => {
+      try {
+        const { id, ...updateData } = params;
+        const result = await api("PUT", `bots/${id}`, updateData);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Delete Bot
+  server.registerTool(
+    "neuron_delete_bot",
+    {
+      title: "Delete Bot",
+      description: "Permanently delete a bot and all its associated data. This action cannot be undone.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot to delete"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("DELETE", `bots/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Pause Bot
+  server.registerTool(
+    "neuron_pause_bot",
+    {
+      title: "Pause Bot",
+      description: "Pause a bot to temporarily stop it from processing new messages. The bot retains its configuration and can be resumed later.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot to pause"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `bots/${params.id}/pause`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Resume Bot
+  server.registerTool(
+    "neuron_resume_bot",
+    {
+      title: "Resume Bot",
+      description: "Resume a previously paused bot so it begins processing new messages again.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot to resume"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `bots/${params.id}/resume`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get Bot Analytics
+  server.registerTool(
+    "neuron_get_bot_analytics",
+    {
+      title: "Get Bot Analytics",
+      description: "Retrieve analytics and usage statistics for a specific bot, including message counts, response times, and conversation metrics.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot to retrieve analytics for"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `bots/${params.id}/analytics`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Attach Knowledge Base
+  server.registerTool(
+    "neuron_attach_knowledge_base",
+    {
+      title: "Attach Knowledge Base",
+      description: "Attach a knowledge base to a bot to enhance its responses with domain-specific knowledge. Optional priority determines retrieval order when multiple knowledge bases are attached.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot"),
+        knowledgeBaseId: z.string().describe("Unique identifier (UUID) of the knowledge base to attach"),
+        priority: z.number().optional().describe("Priority level for knowledge base retrieval (higher values are checked first)"),
+      }),
+    },
+    async (params) => {
+      try {
+        const { id, ...attachData } = params;
+        const result = await api("POST", `bots/${id}/knowledge-bases`, attachData);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // List Bot Knowledge Bases
+  server.registerTool(
+    "neuron_list_bot_knowledge_bases",
+    {
+      title: "List Bot Knowledge Bases",
+      description: "Retrieve all knowledge bases attached to a specific bot, including their priorities and metadata.",
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `bots/${params.id}/knowledge-bases`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Detach Knowledge Base
+  server.registerTool(
+    "neuron_detach_knowledge_base",
+    {
+      title: "Detach Knowledge Base",
+      description: "Remove a knowledge base from a bot. The bot will no longer reference this knowledge base when generating responses.",
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the bot"),
+        kbId: z.string().describe("Unique identifier (UUID) of the knowledge base to detach"),
+      }),
+    },
+    async (params) => {
+      try {
+        const result = await api("DELETE", `bots/${params.id}/knowledge-bases/${params.kbId}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}

package/src/tools/broadcasts.ts

@@ -0,0 +1,224 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+export function registerBroadcastsTools(server: McpServer): void {
+  // List broadcasts
+  server.registerTool(
+    "neuron_list_broadcasts",
+    {
+      title: "List Broadcasts",
+      description: "Retrieve a paginated list of all broadcasts with optional filtering by status such as draft, sent, or scheduled.",
+      inputSchema: z.object({
+        status: z.string().optional().describe("Filter by broadcast status (e.g., 'draft', 'sent', 'scheduled')"),
+        page: z.number().int().positive().optional().describe("Page number for pagination (default: 1)"),
+        limit: z.number().int().positive().optional().describe("Number of broadcasts per page (default: 20)"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", "/broadcasts", undefined, {
+          status: params.status,
+          page: params.page,
+          limit: params.limit,
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Create broadcast
+  server.registerTool(
+    "neuron_create_broadcast",
+    {
+      title: "Create Broadcast",
+      description: "Create a new broadcast message in draft status. Provide recipients directly or use recipientSources to resolve from contact lists. The WhatsApp channel is auto-resolved if not specified.",
+      inputSchema: z.object({
+        channelId: z.string().optional().describe("Identifier (UUID) of the WhatsApp channel to send through (auto-resolved from default channel if omitted)"),
+        botId: z.string().optional().describe("Identifier (UUID) of a bot to send through. Each recipient's channel is picked by the bot's load-balancer + sticky sessions. Takes precedence over channelId."),
+        name: z.string().describe("Display name or label for the broadcast"),
+        message: z.string().describe("Message content to broadcast to recipients"),
+        messageType: z.string().optional().describe("Type of message to send (e.g., 'text', 'image', 'document')"),
+        mediaUrl: z.string().optional().describe("URL of media to attach (required for image or document message types)"),
+        recipients: z.array(z.object({
+          phone: z.string().describe("Recipient phone number in E.164 format (e.g., '+2348012345678')"),
+          contactName: z.string().optional().describe("Display name of the recipient contact"),
+        })).optional().describe("Direct list of recipients (alternative to recipientSources)"),
+        recipientSources: z.object({
+          listIds: z.array(z.string()).optional().describe("Contact list identifiers (UUIDs or slugs) to include as recipients"),
+          phones: z.array(z.string()).optional().describe("Individual phone numbers in E.164 format to include"),
+          filters: z.object({
+            tags: z.array(z.string()).optional().describe("Only include contacts matching these tags"),
+          }).optional().describe("Additional filters to narrow down recipients"),
+          excludeListIds: z.array(z.string()).optional().describe("Contact list identifiers (UUIDs or slugs) to exclude from recipients"),
+        }).optional().describe("Resolve recipients dynamically from contact lists with filtering and exclusion"),
+        scheduledAt: z.string().optional().describe("ISO 8601 date-time for scheduled broadcast delivery (e.g., '2025-12-31T10:00:00Z'). Creates as draft if omitted."),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", "/broadcasts", params);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get broadcast
+  server.registerTool(
+    "neuron_get_broadcast",
+    {
+      title: "Get Broadcast",
+      description: "Retrieve detailed information about a specific broadcast, including its status, message content, and recipient summary.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the broadcast to retrieve"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("GET", `/broadcasts/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Get broadcast recipients
+  server.registerTool(
+    "neuron_get_broadcast_recipients",
+    {
+      title: "Get Broadcast Recipients",
+      description: "Retrieve the paginated list of recipients for a specific broadcast with their individual delivery status.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the broadcast"),
+        status: z.string().optional().describe("Filter recipients by delivery status (e.g., 'delivered', 'failed', 'pending')"),
+        page: z.number().int().positive().optional().describe("Page number for pagination (default: 1)"),
+        limit: z.number().int().positive().optional().describe("Number of recipients per page (default: 20)"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const { id, ...query } = params;
+        const result = await api("GET", `/broadcasts/${id}/recipients`, undefined, {
+          status: query.status,
+          page: query.page,
+          limit: query.limit,
+        });
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Update broadcast
+  server.registerTool(
+    "neuron_update_broadcast",
+    {
+      title: "Update Broadcast",
+      description: "Update an existing broadcast's name, message content, or media before sending. The broadcast must still be in draft status.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the broadcast to update"),
+        name: z.string().optional().describe("New display name or label for the broadcast"),
+        message: z.string().optional().describe("New message content to broadcast"),
+        messageType: z.string().optional().describe("New message type (e.g., 'text', 'image', 'document')"),
+        mediaUrl: z.string().optional().describe("New media URL to attach"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const { id, ...body } = params;
+        const result = await api("PUT", `/broadcasts/${id}`, body);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Delete broadcast
+  server.registerTool(
+    "neuron_delete_broadcast",
+    {
+      title: "Delete Broadcast",
+      description: "Permanently delete a broadcast and its recipient data. This action cannot be undone.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the broadcast to delete"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("DELETE", `/broadcasts/${params.id}`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+
+  // Send broadcast
+  server.registerTool(
+    "neuron_send_broadcast",
+    {
+      title: "Send Broadcast",
+      description: "Send a broadcast message to all its recipients. The broadcast must be in draft status. This triggers message delivery and cannot be undone.",
+      inputSchema: z.object({
+        id: z.string().describe("Unique identifier (UUID) of the broadcast to send"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+      },
+    },
+    async (params) => {
+      try {
+        const result = await api("POST", `/broadcasts/${params.id}/send`);
+        return jsonResult(result);
+      } catch (error) {
+        return errorResult(error);
+      }
+    }
+  );
+}

package/src/tools/builtin-tools.ts

@@ -0,0 +1,108 @@
+import { z } from "zod";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { api, jsonResult, errorResult } from "../client.js";
+
+/**
+ * Register built-in tool management tools (enable/disable per bot)
+ */
+export function registerBuiltinToolsTools(server: McpServer): void {
+  // 1. List Built-in Tools
+  server.registerTool(
+    "neuron_list_builtin_tools",
+    {
+      title: "List Built-in Tools",
+      description:
+        "Retrieve all available built-in tools with their enabled/disabled status for a specific bot. " +
+        "Built-in tools include WhatsApp actions (send messages, delete messages, post status), " +
+        "utility functions (web search, QR codes, weather), scheduling, knowledge base search, and more.",
+      inputSchema: z.object({
+        botId: z.string().describe("Unique identifier (UUID) of the bot to list built-in tools for"),
+      }),
+      annotations: {
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
+    },
+    async (args) => {
+      const response = await api("GET", `/builtin-tools/bot/${args.botId}`);
+
+      if (response.success) {
+        return jsonResult(response.data);
+      } else {
+        return errorResult(response.error || "Failed to list built-in tools");
+      }
+    }
+  );
+
+  // 2. Toggle Built-in Tool
+  server.registerTool(
+    "neuron_toggle_builtin_tool",
+    {
+      title: "Toggle Built-in Tool",
+      description:
+        "Toggle a built-in tool on or off for a specific bot. Enabled tools become available in the bot's conversations. " +
+        "Example tool IDs: delete_message, post_to_channel, post_status, web_search, " +
+        "send_direct_message, react_to_message, set_reminder, create_poll.",
+      inputSchema: z.object({
+        botId: z.string().describe("Unique identifier (UUID) of the bot to toggle the tool for"),
+        toolId: z.string().describe("Identifier of the built-in tool (e.g., 'delete_message', 'post_status', 'web_search')"),
+        enabled: z.boolean().describe("Whether to enable (true) or disable (false) the tool"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
+    },
+    async (args) => {
+      const { botId, toolId, enabled } = args;
+      const response = await api("PUT", `/builtin-tools/bot/${botId}/${toolId}`, { enabled });
+
+      if (response.success) {
+        return jsonResult(response.data);
+      } else {
+        return errorResult(response.error || "Failed to toggle built-in tool");
+      }
+    }
+  );
+
+  // 3. Bulk Toggle Built-in Tools
+  server.registerTool(
+    "neuron_bulk_toggle_builtin_tools",
+    {
+      title: "Bulk Toggle Built-in Tools",
+      description:
+        "Enable or disable multiple built-in tools at once for a bot. More efficient than toggling tools individually.",
+      inputSchema: z.object({
+        botId: z.string().describe("Unique identifier (UUID) of the bot to update tools for"),
+        settings: z
+          .array(
+            z.object({
+              toolId: z.string().describe("Identifier of the built-in tool (e.g., 'web_search', 'send_direct_message')"),
+              enabled: z.boolean().describe("Whether to enable (true) or disable (false) this tool"),
+            })
+          )
+          .describe("Array of tool toggle settings to apply in bulk"),
+      }),
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+      },
+    },
+    async (args) => {
+      const { botId, settings } = args;
+      const response = await api("PUT", `/builtin-tools/bot/${botId}/bulk`, { settings });
+
+      if (response.success) {
+        return jsonResult(response.data);
+      } else {
+        return errorResult(response.error || "Failed to bulk toggle built-in tools");
+      }
+    }
+  );
+}