@wabery/cli 0.12.0 → 0.14.0

package/dist/mcp-server.js

@@ -1,4 +1,4 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { WaberyApiClient, WaberyApiError } from "./api-client.js";
 import { createExampleConfig } from "./config-example.js";
@@ -16,6 +16,11 @@ const readinessRequirementSchema = z.enum([
 ]);
 const optInSchema = z
     .object({
+    categories: z
+        .array(z.enum(["GENERAL", "MARKETING", "UTILITY", "AUTHENTICATION"]))
+        .min(1)
+        .max(4)
+        .optional(),
     source: z.string().min(1).max(120),
     method: z.string().min(1).max(80).optional(),
     occurred_at: z.string().datetime().optional(),
@@ -23,9 +28,67 @@ const optInSchema = z
     evidence: z.record(z.string(), z.unknown()).optional(),
 })
     .optional();
-const SERVER_INSTRUCTIONS = `Use Wabery tools as a developer platform for WhatsApp, Instagram, and Messenger messaging: channels, routing, contacts, registration intents, conversations, message history, outbound messages, inbound media metadata, WhatsApp Flows, templates, automations, webhooks, and Meta Business Agent extensions.
+const broadcastStatusSchema = z.enum([
+    "draft",
+    "preparing",
+    "ready",
+    "scheduled",
+    "sending",
+    "completed",
+    "canceled",
+    "failed",
+]);
+const broadcastRecipientStatusSchema = z.enum([
+    "pending",
+    "queued",
+    "sending",
+    "sent",
+    "delivered",
+    "read",
+    "failed",
+    "skipped",
+    "canceled",
+]);
+const broadcastParameterMappingSchema = z.object({
+    component: z.enum(["header", "body", "button"]),
+    index: z.number().int().min(0),
+    button_index: z.number().int().min(0).optional(),
+    parameter_type: z
+        .enum(["text", "image", "document", "video"])
+        .default("text"),
+    source: z.enum([
+        "name",
+        "phone",
+        "preferred_language",
+        "metadata",
+        "constant",
+    ]),
+    metadata_key: z.string().min(1).max(120).optional(),
+    value: z.string().max(2000).optional(),
+    fallback: z.string().max(2000).optional(),
+});
+const broadcastVariantSchema = z.object({
+    template_id: z.string().min(1),
+    language: z.string().min(2).max(35),
+    parameter_mappings: z.array(broadcastParameterMappingSchema).max(100),
+});
+const broadcastAudienceFilterSchema = z.object({
+    search: z.string().max(120).optional(),
+    tags: z.array(z.string().min(1).max(60)).max(50).optional(),
+    languages: z.array(z.string().min(2).max(35)).max(50).optional(),
+    is_blocked: z.boolean().optional(),
+    created_after: z.string().datetime().optional(),
+    created_before: z.string().datetime().optional(),
+});
+const toolOutputSchema = {
+    result: z
+        .record(z.string(), z.unknown())
+        .describe("The structured Wabery API result object. Its operation-specific fields are described by the tool and Wabery API documentation."),
+};
+const SERVER_INSTRUCTIONS = `Use Wabery tools as a developer platform for WhatsApp, Instagram, and Messenger messaging: channels, routing, contacts, registration intents, conversations, message history, outbound messages, inbound media metadata, WhatsApp Flows, templates, broadcasts, automations, webhooks, and Meta Business Agent extensions.
 Recommended order: read wabery_get_config_schema, select the project, call wabery_get_project_readiness, list channels only when more channel detail is needed, check Business Agent eligibility before adding business_agent config, create registration intents or enroll WhatsApp contacts as needed, store returned contact_id plus channel_id, validate and preview config diff, apply config only after review, publish flows only after explicit confirmation, then send messages or published flows with channel_id and contact_id/conversation_id.
 Always distinguish sandbox testing from production readiness: a project without its own connected phone number can often still be tested in the shared Wabery sandbox, but production inbound traffic requires a dedicated project channel. For WhatsApp templates and proactive reminders, inspect readiness before creation: template submission and proactive template sends require a dedicated non-sandbox WhatsApp channel, Meta business verification/account approval, a connected phone, and a Meta payment method. After sending a message, use wabery_get_message to inspect provider status and failures.
+For broadcasts, use only approved WhatsApp templates on a dedicated channel and only contacts with valid category-specific consent. Create a draft, prepare exactly one audience source, poll wabery_get_broadcast until it is ready, inspect its counts and excluded recipients, and send or schedule only after explicit user confirmation. Preparation freezes the recipient snapshot; create a new draft when the intended audience changes. CSV files are uploaded through the dashboard or CLI; use wabery_list_contact_imports and wabery_get_contact_import to select a completed import.
 Use wabery_list_conversations, wabery_get_conversation, and wabery_list_conversation_messages to inspect history. Inbound WhatsApp media appears on message records/webhooks as media/assets metadata with Wabery signed URLs when retained; download files promptly because URLs are short-lived and retention is plan-based.
 Config apply creates or updates Wabery flows, automations, webhook settings, and eligible Meta Business Agent declarations. It never publishes flows to Meta. Automations and Business Agent connector tools can trigger flows through references to flow config keys.
 High-risk tools require confirmation_token values shown in each tool description.`;
@@ -40,10 +103,57 @@ const WRITE_NOTE = {
 function serverInstructions(writePolicy) {
     return `${SERVER_INSTRUCTIONS}\n${WRITE_NOTE[writePolicy]}`;
 }
+const MCP_SENSITIVE_OUTPUT_KEY_SUFFIXES = [
+    "accesstoken",
+    "apikey",
+    "authorizationheader",
+    "authtoken",
+    "bearertoken",
+    "credential",
+    "credentials",
+    "idtoken",
+    "jwt",
+    "password",
+    "passwordhash",
+    "privatekey",
+    "providertoken",
+    "refreshtoken",
+    "secret",
+    "serviceproof",
+    "sessiontoken",
+    "signingkey",
+    "stacktrace",
+];
+const MCP_INTERNAL_OUTPUT_KEYS = new Set([
+    "debugid",
+    "internaldebugid",
+    "requestid",
+    "traceid",
+]);
+function isSensitiveMcpOutputKey(key) {
+    const normalizedKey = key.replaceAll(/[^a-zA-Z0-9]/g, "").toLowerCase();
+    return (MCP_INTERNAL_OUTPUT_KEYS.has(normalizedKey) ||
+        MCP_SENSITIVE_OUTPUT_KEY_SUFFIXES.some((suffix) => normalizedKey.endsWith(suffix)));
+}
+function sanitizeMcpOutput(data) {
+    if (Array.isArray(data)) {
+        return data.map((item) => sanitizeMcpOutput(item));
+    }
+    if (!data || typeof data !== "object") {
+        return data;
+    }
+    return Object.fromEntries(Object.entries(data).flatMap(([key, value]) => isSensitiveMcpOutputKey(key) ? [] : [[key, sanitizeMcpOutput(value)]]));
+}
 function jsonResult(data) {
+    const sanitizedData = sanitizeMcpOutput(data);
     return {
-        content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
-        structuredContent: { result: data },
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(sanitizedData, null, 2),
+            },
+        ],
+        structuredContent: { result: sanitizedData },
     };
 }
 function errorResult(data) {
@@ -89,11 +199,85 @@ function checkWriteMode(action, token, expectedToken, writePolicy = "env") {
 }
 export function createWaberyMcpServer(client = new WaberyApiClient(), options = {}) {
     const writePolicy = options.writePolicy ?? "env";
-    const requireWrite = (action, token, expectedToken) => checkWriteMode(action, token, expectedToken, writePolicy);
     const server = new McpServer({
         name: "wabery",
         version: options.serverVersion ?? "0.1.0",
     }, { instructions: serverInstructions(writePolicy) });
+    const registerTool = (name, config, callback) => server.registerTool(name, {
+        outputSchema: toolOutputSchema,
+        ...config,
+    }, callback);
+    const requireWrite = async (action, token, expectedToken) => {
+        const modeBlocked = checkWriteMode(action, undefined, undefined, writePolicy);
+        if (modeBlocked)
+            return modeBlocked;
+        if (!expectedToken)
+            return null;
+        if (server.server.getClientCapabilities()?.elicitation) {
+            const response = await server.server.elicitInput({
+                message: `Approve the high-risk Wabery action: ${action}`,
+                requestedSchema: {
+                    type: "object",
+                    properties: {
+                        confirm: {
+                            type: "boolean",
+                            title: "Confirm action",
+                            description: "Approve this external or destructive action",
+                            default: false,
+                        },
+                    },
+                    required: ["confirm"],
+                },
+            });
+            if (response.action === "accept" && response.content?.confirm === true) {
+                return null;
+            }
+            return errorResult({
+                action,
+                message: "The user declined or canceled the action.",
+            });
+        }
+        if (writePolicy === "enabled") {
+            return errorResult({
+                action,
+                message: "This hosted MCP client must support elicitation so Wabery can obtain real user approval.",
+            });
+        }
+        return checkWriteMode(action, token, expectedToken, writePolicy);
+    };
+    const requireBroadcastApproval = async (action, message, token, localConfirmationToken) => {
+        if (server.server.getClientCapabilities()?.elicitation) {
+            const response = await server.server.elicitInput({
+                message,
+                requestedSchema: {
+                    type: "object",
+                    properties: {
+                        confirm: {
+                            type: "boolean",
+                            title: "Confirm broadcast action",
+                            description: "Approve this external messaging action",
+                            default: false,
+                        },
+                    },
+                    required: ["confirm"],
+                },
+            });
+            if (response.action === "accept" && response.content?.confirm === true) {
+                return null;
+            }
+            return errorResult({
+                action,
+                message: "The user declined or canceled the broadcast action.",
+            });
+        }
+        if (writePolicy === "enabled") {
+            return errorResult({
+                action,
+                message: "This hosted MCP client must support elicitation so Wabery can obtain real user approval.",
+            });
+        }
+        return await requireWrite(action, token, localConfirmationToken);
+    };
     const resolveProjectId = async (projectId) => {
         if (projectId)
             return projectId;
@@ -164,7 +348,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             },
         ],
     }));
-    server.registerTool("wabery_check_connection", {
+    registerTool("wabery_check_connection", {
         title: "Check Wabery connection",
         description: "Verify the configured API key can reach Wabery projects, channels, and the config schema before making changes.",
         inputSchema: {},
@@ -175,7 +359,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await checkWaberyConnection(client)));
-    server.registerTool("wabery_get_config_example", {
+    registerTool("wabery_get_config_example", {
         title: "Get example Wabery config",
         description: "Return a starter wabery.config.json with one flow and one automation that triggers it with a send_flow step.",
         inputSchema: {
@@ -192,7 +376,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id }) => jsonResult(createExampleConfig(project_id)));
-    server.registerTool("wabery_get_config_schema", {
+    registerTool("wabery_get_config_schema", {
         title: "Get Wabery config schema",
         description: "Return the JSON Schema for wabery.config.json. Use this before generating flows, automations, webhooks, or business_agent declarations.",
         inputSchema: {},
@@ -203,7 +387,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/config/schema")));
-    server.registerTool("wabery_export_config", {
+    registerTool("wabery_export_config", {
         title: "Export Wabery config",
         description: "Export the organization's flows, automations, webhook settings, and Business Agent declarations as a config object.",
         inputSchema: {},
@@ -214,7 +398,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/config")));
-    server.registerTool("wabery_validate_config", {
+    registerTool("wabery_validate_config", {
         title: "Validate Wabery config",
         description: "Validate a declarative config object without changing flows or automations.",
         inputSchema: {
@@ -227,7 +411,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ config }) => apiResult(client.post("/config/validate", config)));
-    server.registerTool("wabery_preview_config_diff", {
+    registerTool("wabery_preview_config_diff", {
         title: "Preview Wabery config diff",
         description: "Preview which flows, automations, webhook settings, Business Agents, connectors, and tools would be created, updated, deleted, or left unchanged.",
         inputSchema: {
@@ -240,7 +424,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ config }) => apiResult(client.post("/config/diff", config)));
-    server.registerTool("wabery_apply_config", {
+    registerTool("wabery_apply_config", {
         title: "Apply Wabery config",
         description: "Create, update, or remove Wabery flows, automations, webhook settings, and eligible Business Agent declarations from config. This does not publish flows to Meta; call wabery_publish_flow explicitly after review.",
         inputSchema: {
@@ -258,7 +442,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { config, confirmation_token } = input;
-        const blocked = requireWrite("wabery_apply_config", confirmation_token, "apply_config");
+        const blocked = await requireWrite("wabery_apply_config", confirmation_token, "apply_config");
         if (blocked)
             return blocked;
         try {
@@ -282,7 +466,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             throw error;
         }
     });
-    server.registerTool("wabery_list_business_agents", {
+    registerTool("wabery_list_business_agents", {
         title: "List Meta Business Agents",
         description: "List Meta Business Agent records for the selected Wabery project.",
         inputSchema: {
@@ -297,7 +481,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ channel_id }) => jsonResult(await client.get("/business-agents", {
         channel_id,
     })));
-    server.registerTool("wabery_check_business_agent_eligibility", {
+    registerTool("wabery_check_business_agent_eligibility", {
         title: "Check Meta Business Agent eligibility",
         description: "Check whether a WhatsApp channel is eligible for Meta Business Agent.",
         inputSchema: {
@@ -312,7 +496,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ channel_id }) => jsonResult(await client.get("/business-agents/eligibility", {
         channel_id,
     })));
-    server.registerTool("wabery_apply_business_agent", {
+    registerTool("wabery_apply_business_agent", {
         title: "Apply Meta Business Agent settings",
         description: "Provision or update a Meta Business Agent for a WhatsApp channel. Prefer wabery_apply_config when managing the whole project declaratively.",
         inputSchema: {
@@ -335,12 +519,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_apply_business_agent", confirmation_token, "apply_business_agent");
+        const blocked = await requireWrite("wabery_apply_business_agent", confirmation_token, "apply_business_agent");
         if (blocked)
             return blocked;
         return jsonResult(await client.put("/business-agents", body));
     });
-    server.registerTool("wabery_get_business_agent_settings", {
+    registerTool("wabery_get_business_agent_settings", {
         title: "Get Meta Business Agent settings",
         description: "Retrieve live Meta Business Agent settings.",
         inputSchema: {
@@ -353,7 +537,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: true,
         },
     }, async ({ business_agent_id }) => jsonResult(await client.get(`/business-agents/${encodeURIComponent(business_agent_id)}/settings`)));
-    server.registerTool("wabery_update_business_agent_settings", {
+    registerTool("wabery_update_business_agent_settings", {
         title: "Update Meta Business Agent settings",
         description: "Update live Meta Business Agent settings.",
         inputSchema: {
@@ -376,12 +560,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { business_agent_id, confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_update_business_agent_settings", confirmation_token, "update_business_agent_settings");
+        const blocked = await requireWrite("wabery_update_business_agent_settings", confirmation_token, "update_business_agent_settings");
         if (blocked)
             return blocked;
         return jsonResult(await client.put(`/business-agents/${encodeURIComponent(business_agent_id)}/settings`, body));
     });
-    server.registerTool("wabery_list_business_agent_connectors", {
+    registerTool("wabery_list_business_agent_connectors", {
         title: "List Meta Business Agent connectors",
         description: "List connector records for Meta Business Agents in the selected Wabery project.",
         inputSchema: {
@@ -396,7 +580,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ business_agent_id }) => jsonResult(await client.get("/business-agents/connectors", {
         business_agent_id,
     })));
-    server.registerTool("wabery_create_business_agent_connector", {
+    registerTool("wabery_create_business_agent_connector", {
         title: "Create Meta Business Agent connector",
         description: "Create a connector on a provisioned Meta Business Agent. Prefer wabery_apply_config for declarative project-wide changes.",
         inputSchema: {
@@ -418,12 +602,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_create_business_agent_connector", confirmation_token, "create_business_agent_connector");
+        const blocked = await requireWrite("wabery_create_business_agent_connector", confirmation_token, "create_business_agent_connector");
         if (blocked)
             return blocked;
         return jsonResult(await client.post("/business-agents/connectors", body));
     });
-    server.registerTool("wabery_create_business_agent_connector_tool", {
+    registerTool("wabery_create_business_agent_connector_tool", {
         title: "Create Meta Business Agent connector tool",
         description: "Create a connector tool backed by a Wabery Flow, hosted function, API endpoint, or no-op placeholder.",
         inputSchema: {
@@ -453,12 +637,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { connector_id, confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_create_business_agent_connector_tool", confirmation_token, "create_business_agent_connector_tool");
+        const blocked = await requireWrite("wabery_create_business_agent_connector_tool", confirmation_token, "create_business_agent_connector_tool");
         if (blocked)
             return blocked;
         return jsonResult(await client.post(`/business-agents/connectors/${encodeURIComponent(connector_id)}/tools`, body));
     });
-    server.registerTool("wabery_list_business_agent_connector_tools", {
+    registerTool("wabery_list_business_agent_connector_tools", {
         title: "List Meta Business Agent connector tools",
         description: "List tools for a Meta Business Agent connector.",
         inputSchema: {
@@ -471,7 +655,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ connector_id }) => jsonResult(await client.get(`/business-agents/connectors/${encodeURIComponent(connector_id)}/tools`)));
-    server.registerTool("wabery_get_business_agent_connector_tool", {
+    registerTool("wabery_get_business_agent_connector_tool", {
         title: "Get Meta Business Agent connector tool",
         description: "Fetch one Meta Business Agent connector tool.",
         inputSchema: {
@@ -485,7 +669,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ connector_id, tool_id }) => jsonResult(await client.get(`/business-agents/connectors/${encodeURIComponent(connector_id)}/tools/${encodeURIComponent(tool_id)}`)));
-    server.registerTool("wabery_update_business_agent_connector_tool", {
+    registerTool("wabery_update_business_agent_connector_tool", {
         title: "Update Meta Business Agent connector tool",
         description: "Update one Meta Business Agent connector tool.",
         inputSchema: {
@@ -513,12 +697,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { connector_id, tool_id, confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_update_business_agent_connector_tool", confirmation_token, "update_business_agent_connector_tool");
+        const blocked = await requireWrite("wabery_update_business_agent_connector_tool", confirmation_token, "update_business_agent_connector_tool");
         if (blocked)
             return blocked;
         return jsonResult(await client.patch(`/business-agents/connectors/${encodeURIComponent(connector_id)}/tools/${encodeURIComponent(tool_id)}`, body));
     });
-    server.registerTool("wabery_delete_business_agent_connector_tool", {
+    registerTool("wabery_delete_business_agent_connector_tool", {
         title: "Delete Meta Business Agent connector tool",
         description: "Delete one Meta Business Agent connector tool.",
         inputSchema: {
@@ -536,16 +720,35 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ connector_id, tool_id, confirmation_token }) => {
-        const blocked = requireWrite("wabery_delete_business_agent_connector_tool", confirmation_token, "delete_business_agent_connector_tool");
+        const blocked = await requireWrite("wabery_delete_business_agent_connector_tool", confirmation_token, "delete_business_agent_connector_tool");
         if (blocked)
             return blocked;
         return jsonResult(await client.delete(`/business-agents/connectors/${encodeURIComponent(connector_id)}/tools/${encodeURIComponent(tool_id)}`));
     });
-    server.registerTool("wabery_business_agent_thread_control", {
+    registerTool("wabery_get_business_agent_thread_control", {
+        title: "Get Meta Business Agent thread control",
+        description: "Inspect WhatsApp thread control for a channel/contact pair without changing its owner.",
+        inputSchema: {
+            channel_id: z.string().min(1),
+            contact_id: z.string().min(1),
+            business_agent_id: z.string().min(1).optional(),
+            thread_id: z.string().min(1).optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async (input) => jsonResult(await client.post("/business-agents/thread-control", {
+        ...input,
+        action: "get",
+    })));
+    registerTool("wabery_set_business_agent_thread_control", {
         title: "Set Meta Business Agent thread control",
-        description: "Take, pass, or inspect WhatsApp thread control for a channel/contact pair.",
+        description: "Take or pass WhatsApp thread control for a channel/contact pair. Use the separate get tool to inspect current ownership.",
         inputSchema: {
-            action: z.enum(["take", "pass", "get"]),
+            action: z.enum(["take", "pass"]),
             channel_id: z.string().min(1),
             contact_id: z.string().min(1),
             business_agent_id: z.string().min(1).optional(),
@@ -561,16 +764,16 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             readOnlyHint: false,
             destructiveHint: false,
             idempotentHint: true,
-            openWorldHint: false,
+            openWorldHint: true,
         },
     }, async (input) => {
         const { confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_business_agent_thread_control", confirmation_token, "thread_control");
+        const blocked = await requireWrite("wabery_set_business_agent_thread_control", confirmation_token, "thread_control");
         if (blocked)
             return blocked;
         return jsonResult(await client.post("/business-agents/thread-control", body));
     });
-    server.registerTool("wabery_test_business_agent", {
+    registerTool("wabery_test_business_agent", {
         title: "Test Meta Business Agent",
         description: "Run a Meta Business Agent test scenario.",
         inputSchema: {
@@ -585,7 +788,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: true,
         },
     }, async (body) => jsonResult(await client.post("/business-agents/test", body)));
-    server.registerTool("wabery_get_business_agent_eval", {
+    registerTool("wabery_get_business_agent_eval", {
         title: "Get Meta Business Agent eval summary",
         description: "Retrieve the Meta Business Agent eval summary.",
         inputSchema: {
@@ -600,7 +803,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ business_agent_id }) => jsonResult(await client.get("/business-agents/eval", {
         business_agent_id,
     })));
-    server.registerTool("wabery_list_business_agent_skills", {
+    registerTool("wabery_list_business_agent_skills", {
         title: "List Meta Business Agent skills",
         description: "List configured Meta Business Agent skills.",
         inputSchema: {
@@ -615,7 +818,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ business_agent_id }) => jsonResult(await client.get("/business-agents/skills", {
         business_agent_id,
     })));
-    server.registerTool("wabery_set_business_agent_skills", {
+    registerTool("wabery_set_business_agent_skills", {
         title: "Set Meta Business Agent skills",
         description: "Replace configured Meta Business Agent skills.",
         inputSchema: {
@@ -628,17 +831,17 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: true,
             openWorldHint: true,
         },
     }, async ({ confirmation_token, ...body }) => {
-        const blocked = requireWrite("wabery_set_business_agent_skills", confirmation_token, "set_business_agent_skills");
+        const blocked = await requireWrite("wabery_set_business_agent_skills", confirmation_token, "set_business_agent_skills");
         if (blocked)
             return blocked;
         return jsonResult(await client.put("/business-agents/skills", body));
     });
-    server.registerTool("wabery_list_projects", {
+    registerTool("wabery_list_projects", {
         title: "List Wabery projects",
         description: "List projects and their project_id values. Use project_id when creating flows or enrolling WhatsApp contacts.",
         inputSchema: {},
@@ -650,7 +853,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async () => jsonResult(await client.get("/projects")));
     if (options.projectSelection) {
-        server.registerTool("wabery_get_selected_project", {
+        registerTool("wabery_get_selected_project", {
             title: "Get selected Wabery project",
             description: "Return the project currently selected for this MCP session. If no project has been selected, Wabery uses the credential's default project.",
             inputSchema: {},
@@ -665,14 +868,14 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             selected_project_id: options.projectSelection?.get() ?? null,
             default_project_id: client.projectId ?? null,
         }));
-        server.registerTool("wabery_select_project", {
+        registerTool("wabery_select_project", {
             title: "Select Wabery project",
             description: "Select the project that subsequent Wabery MCP tools should use in this session. Call wabery_list_projects first, then pass the project_id.",
             inputSchema: {
                 project_id: z.string().min(1),
             },
             annotations: {
-                readOnlyHint: true,
+                readOnlyHint: false,
                 destructiveHint: false,
                 idempotentHint: true,
                 openWorldHint: false,
@@ -687,7 +890,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             });
         });
     }
-    server.registerTool("wabery_get_project_readiness", {
+    registerTool("wabery_get_project_readiness", {
         title: "Get Wabery project readiness",
         description: "Explain what the selected project can do now: sandbox testing, production inbound, flow publish/send, templates, proactive messages, routing, opt-in, and submission handling. Call before building, after wabery_apply_config, before template/reminder work, and before the final creator summary.",
         inputSchema: {
@@ -701,9 +904,9 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id, requirements }) => jsonResult(await getReadiness(project_id, requirements)));
-    server.registerTool("wabery_get_project", {
+    registerTool("wabery_get_project", {
         title: "Get a Wabery project",
-        description: "Fetch a single project, including its webhook_secret (revealed only here, never in wabery_list_projects).",
+        description: "Fetch a single project's user-safe configuration. Secrets and provider credentials are omitted from MCP results.",
         inputSchema: { project_id: z.string().min(1) },
         annotations: {
             readOnlyHint: true,
@@ -712,7 +915,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id }) => jsonResult(await client.get(`/projects/${encodeURIComponent(project_id)}`)));
-    server.registerTool("wabery_update_project", {
+    registerTool("wabery_update_project", {
         title: "Update a Wabery project",
         description: "Update name, description, routing_mode, require_opt_in, or webhook config (url, signing on/off, or a bring-your-own secret) of an existing project. Set require_opt_in=false on a dedicated production number so inbound senders can be replied to and messaged without the invite/opt-in step.",
         inputSchema: {
@@ -732,14 +935,14 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id, ...body }) => {
-        const blocked = requireWrite("wabery_update_project");
+        const blocked = await requireWrite("wabery_update_project");
         if (blocked)
             return blocked;
         return jsonResult(await client.patch(`/projects/${encodeURIComponent(project_id)}`, body));
     });
-    server.registerTool("wabery_rotate_webhook_secret", {
+    registerTool("wabery_rotate_webhook_secret", {
         title: "Rotate a project's webhook secret",
-        description: "Set a new signing secret (server-generated, or a provided one) and return it once. Invalidates the previous secret.",
+        description: "Set a new signing secret (server-generated, or a provided one) and invalidate the previous secret. MCP confirms the rotation but omits the secret value; retrieve or manage sensitive credentials in the Wabery dashboard.",
         inputSchema: {
             project_id: z.string().min(1),
             webhook_secret: z.string().min(16).max(256).optional(),
@@ -751,12 +954,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id, webhook_secret }) => {
-        const blocked = requireWrite("wabery_rotate_webhook_secret");
+        const blocked = await requireWrite("wabery_rotate_webhook_secret");
         if (blocked)
             return blocked;
         return jsonResult(await client.post(`/projects/${encodeURIComponent(project_id)}/rotate-webhook-secret`, webhook_secret ? { webhook_secret } : undefined));
     });
-    server.registerTool("wabery_list_channels", {
+    registerTool("wabery_list_channels", {
         title: "List Wabery channels",
         description: "List connected messaging channels. Use a WhatsApp channel_id when sending a published flow. For WhatsApp templates or proactive template sends, inspect publish_readiness and tell the creator when a dedicated phone number, verified business, approved account, connected phone, or Meta payment method is missing.",
         inputSchema: {},
@@ -767,7 +970,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/channels")));
-    server.registerTool("wabery_get_channel", {
+    registerTool("wabery_get_channel", {
         title: "Get a Wabery channel",
         description: "Fetch a single channel, including routing_warning and WhatsApp publish_readiness. If can_submit_templates is false, explain the blockers before attempting template creation or proactive template sends.",
         inputSchema: { channel_id: z.string().min(1) },
@@ -778,7 +981,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ channel_id }) => jsonResult(await client.get(`/channels/${encodeURIComponent(channel_id)}`)));
-    server.registerTool("wabery_update_channel", {
+    registerTool("wabery_update_channel", {
         title: "Update a Wabery channel's routing",
         description: "Set a dedicated channel's routing_mode (NONE | FLOWS | EXTERNAL). Use EXTERNAL so inbound to this channel is forwarded to the project webhook. The shared sandbox channel routes per-participant and cannot be updated this way.",
         inputSchema: {
@@ -792,14 +995,14 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ channel_id, routing_mode }) => {
-        const blocked = requireWrite("wabery_update_channel");
+        const blocked = await requireWrite("wabery_update_channel");
         if (blocked)
             return blocked;
         return jsonResult(await client.patch(`/channels/${encodeURIComponent(channel_id)}`, {
             routing_mode,
         }));
     });
-    server.registerTool("wabery_create_registration_intent", {
+    registerTool("wabery_create_registration_intent", {
         title: "Create registration intent",
         description: "Mint a single-use wa.me registration link so an end-customer can connect over WhatsApp.",
         inputSchema: {
@@ -821,7 +1024,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ project_id, customer_reference, metadata }) => {
-        const blocked = requireWrite("wabery_create_registration_intent");
+        const blocked = await requireWrite("wabery_create_registration_intent");
         if (blocked)
             return blocked;
         return jsonResult(await client.post("/registration-intents", {
@@ -830,7 +1033,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             metadata,
         }));
     });
-    server.registerTool("wabery_get_registration_intent", {
+    registerTool("wabery_get_registration_intent", {
         title: "Get registration intent",
         description: "Poll a registration intent's status. Works with a publishable key or a scoped secret key.",
         inputSchema: {
@@ -843,7 +1046,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ intent_id }) => jsonResult(await client.get(`/registration-intents/${encodeURIComponent(intent_id)}`)));
-    server.registerTool("wabery_get_limits", {
+    registerTool("wabery_get_limits", {
         title: "Get Wabery API limits",
         description: "Return the enforced public API rate limit and monthly request quota for the configured API key.",
         inputSchema: {},
@@ -854,7 +1057,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/limits")));
-    server.registerTool("wabery_list_flows", {
+    registerTool("wabery_list_flows", {
         title: "List Wabery flows",
         description: "List flows, including ids, config keys, project ids, and Meta publish status.",
         inputSchema: {},
@@ -865,7 +1068,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/flows")));
-    server.registerTool("wabery_get_flow", {
+    registerTool("wabery_get_flow", {
         title: "Get Wabery flow",
         description: "Fetch one flow by id, including status and field schema.",
         inputSchema: {
@@ -878,7 +1081,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ flow_id }) => jsonResult(await client.get(`/flows/${flow_id}`)));
-    server.registerTool("wabery_publish_flow", {
+    registerTool("wabery_publish_flow", {
         title: "Publish Wabery flow",
         description: "Publish a Wabery draft flow to Meta. Only call after validate/diff/apply and explicit user confirmation.",
         inputSchema: {
@@ -890,17 +1093,17 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
         },
     }, async ({ flow_id, confirmation_token }) => {
-        const blocked = requireWrite("wabery_publish_flow", confirmation_token, `publish:${flow_id}`);
+        const blocked = await requireWrite("wabery_publish_flow", confirmation_token, `publish:${flow_id}`);
         if (blocked)
             return blocked;
         return apiResult(client.post(`/flows/${flow_id}/publish`));
     });
-    server.registerTool("wabery_enroll_contact", {
+    registerTool("wabery_enroll_contact", {
         title: "Enroll WhatsApp contact",
         description: "Register a phone number against a Wabery project. Returns contact_id, which is the stable id used in flow submissions and future sends.",
         inputSchema: {
@@ -919,7 +1122,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
                 .optional()
                 .describe("Your own user/customer id for correlation."),
             metadata: metadataSchema,
-            opt_in: optInSchema.describe("WhatsApp opt-in evidence. Include source, method, consent_text, and evidence where available."),
+            opt_in: optInSchema.describe("WhatsApp opt-in evidence. For broadcasts include the applicable MARKETING or UTILITY category plus source, method, consent_text, and evidence."),
         },
         annotations: {
             readOnlyHint: false,
@@ -928,12 +1131,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async (input) => {
-        const blocked = requireWrite("wabery_enroll_contact");
+        const blocked = await requireWrite("wabery_enroll_contact");
         if (blocked)
             return blocked;
         return jsonResult(await client.post("/contacts", input));
     });
-    server.registerTool("wabery_list_contacts", {
+    registerTool("wabery_list_contacts", {
         title: "List Wabery contacts",
         description: "List enrolled contacts and their stable contact_id values.",
         inputSchema: {
@@ -947,7 +1150,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ limit, starting_after }) => jsonResult(await client.get("/contacts", { limit, starting_after })));
-    server.registerTool("wabery_get_contact", {
+    registerTool("wabery_get_contact", {
         title: "Get Wabery contact",
         description: "Fetch one enrolled contact by stable contact_id before sending or unenrolling.",
         inputSchema: {
@@ -960,7 +1163,34 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ contact_id }) => jsonResult(await client.get(`/contacts/${contact_id}`)));
-    server.registerTool("wabery_unenroll_contact", {
+    registerTool("wabery_list_contact_imports", {
+        title: "List Wabery contact imports",
+        description: "List CSV contact imports and their processing counts. Upload files in the dashboard or CLI, then use a completed import_id as a broadcast audience source.",
+        inputSchema: {
+            limit: z.number().int().min(1).max(100).optional(),
+            starting_after: z.string().optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (query) => apiResult(client.get("/contact-imports", query)));
+    registerTool("wabery_get_contact_import", {
+        title: "Get Wabery contact import",
+        description: "Inspect one CSV contact import's status and row counts. Wait for completed before using its import_id to prepare a broadcast.",
+        inputSchema: {
+            import_id: z.string().min(1),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ import_id }) => apiResult(client.get(`/contact-imports/${import_id}`)));
+    registerTool("wabery_unenroll_contact", {
         title: "Unenroll Wabery contact",
         description: "Remove a contact phone's sandbox authorization for this organization. Pass erase=true for irreversible org-scoped contact data deletion.",
         inputSchema: {
@@ -978,12 +1208,234 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ contact_id, erase, confirmation_token }) => {
-        const blocked = requireWrite("wabery_unenroll_contact", confirmation_token, erase ? `erase:${contact_id}` : undefined);
+        const blocked = await requireWrite("wabery_unenroll_contact", confirmation_token, erase ? `erase:${contact_id}` : undefined);
         if (blocked)
             return blocked;
         return jsonResult(await client.delete(`/contacts/${contact_id}${erase ? "?erase=true" : ""}`));
     });
-    server.registerTool("wabery_list_conversations", {
+    registerTool("wabery_list_broadcasts", {
+        title: "List Wabery broadcasts",
+        description: "List broadcast campaigns and delivery counts. Filter by lifecycle status when monitoring preparation or delivery.",
+        inputSchema: {
+            limit: z.number().int().min(1).max(100).optional(),
+            starting_after: z.string().optional(),
+            status: broadcastStatusSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async (query) => apiResult(client.get("/broadcasts", query)));
+    registerTool("wabery_get_broadcast", {
+        title: "Get Wabery broadcast",
+        description: "Fetch one broadcast with its lifecycle status and recipient counts. Poll while status is preparing, and review counts before requesting send or schedule confirmation.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ broadcast_id }) => apiResult(client.get(`/broadcasts/${broadcast_id}`)));
+    registerTool("wabery_create_broadcast", {
+        title: "Create Wabery broadcast draft",
+        description: "Create a draft from approved WhatsApp template variants. This does not select recipients or send messages. Use a dedicated WhatsApp channel and category-specific consent.",
+        inputSchema: {
+            name: z.string().min(1).max(120),
+            channel_id: z.string().min(1),
+            category: z.enum(["MARKETING", "UTILITY"]),
+            template_name: z.string().min(1).max(512),
+            fallback_language: z.string().min(2).max(35),
+            variants: z.array(broadcastVariantSchema).min(1).max(50),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async ({ name, channel_id, category, template_name, fallback_language, variants, }) => {
+        const blocked = await requireWrite("wabery_create_broadcast");
+        if (blocked)
+            return blocked;
+        return apiResult(client.post("/broadcasts", {
+            name,
+            channelId: channel_id,
+            category,
+            templateName: template_name,
+            fallbackLanguage: fallback_language,
+            variants: variants.map((variant) => ({
+                templateId: variant.template_id,
+                language: variant.language,
+                parameterMappings: variant.parameter_mappings.map((mapping) => ({
+                    component: mapping.component,
+                    index: mapping.index,
+                    buttonIndex: mapping.button_index,
+                    parameterType: mapping.parameter_type,
+                    source: mapping.source,
+                    metadataKey: mapping.metadata_key,
+                    value: mapping.value,
+                    fallback: mapping.fallback,
+                })),
+            })),
+        }));
+    });
+    registerTool("wabery_prepare_broadcast_audience", {
+        title: "Prepare Wabery broadcast audience",
+        description: "Resolve and freeze a draft broadcast's recipients from exactly one source: contact_ids, import_id, or filter. Preparation is asynchronous and does not send messages. Poll wabery_get_broadcast until ready, then inspect counts and recipients.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+            contact_ids: z.array(z.string().min(1)).max(1000).optional(),
+            import_id: z.string().min(1).optional(),
+            filter: broadcastAudienceFilterSchema.optional(),
+            exclude_contact_ids: z.array(z.string().min(1)).max(1000).optional(),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ broadcast_id, contact_ids, import_id, filter, exclude_contact_ids, }) => {
+        const blocked = await requireWrite("wabery_prepare_broadcast_audience");
+        if (blocked)
+            return blocked;
+        const sources = [contact_ids, import_id, filter].filter((value) => value !== undefined);
+        if (sources.length !== 1) {
+            return {
+                ...jsonResult({
+                    error: "invalid_audience_source",
+                    message: "Provide exactly one audience source: contact_ids, import_id, or filter.",
+                }),
+                isError: true,
+            };
+        }
+        return apiResult(client.post(`/broadcasts/${broadcast_id}/audience`, {
+            contactIds: contact_ids,
+            importId: import_id,
+            filter: filter
+                ? {
+                    search: filter.search,
+                    tags: filter.tags,
+                    languages: filter.languages,
+                    isBlocked: filter.is_blocked,
+                    createdAfter: filter.created_after,
+                    createdBefore: filter.created_before,
+                }
+                : undefined,
+            excludeContactIds: exclude_contact_ids ?? [],
+        }));
+    });
+    registerTool("wabery_list_broadcast_recipients", {
+        title: "List Wabery broadcast recipients",
+        description: "Inspect the prepared recipient snapshot, language selection, skips, failures, and delivery state. Use before confirmation and while monitoring delivery.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+            limit: z.number().int().min(1).max(100).optional(),
+            starting_after: z.string().optional(),
+            status: broadcastRecipientStatusSchema.optional(),
+        },
+        annotations: {
+            readOnlyHint: true,
+            destructiveHint: false,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ broadcast_id, ...query }) => apiResult(client.get(`/broadcasts/${broadcast_id}/recipients`, query)));
+    registerTool("wabery_send_broadcast", {
+        title: "Send Wabery broadcast",
+        description: "Start sending a ready broadcast to its frozen recipient snapshot. This creates real external WhatsApp messages and requires explicit user confirmation with confirmation_token send_broadcast:<broadcast_id>.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+            confirmation_token: z
+                .string()
+                .optional()
+                .describe("Required: send_broadcast:<broadcast_id>. Obtain explicit user confirmation after reviewing counts."),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ broadcast_id, confirmation_token }) => {
+        const blocked = await requireBroadcastApproval("wabery_send_broadcast", `Send broadcast ${broadcast_id} to its prepared WhatsApp recipients now?`, confirmation_token, `send_broadcast:${broadcast_id}`);
+        if (blocked)
+            return blocked;
+        return apiResult(client.post(`/broadcasts/${broadcast_id}/send`));
+    });
+    registerTool("wabery_schedule_broadcast", {
+        title: "Schedule Wabery broadcast",
+        description: "Schedule a ready broadcast for future delivery to its frozen recipient snapshot. Requires explicit user confirmation with confirmation_token schedule_broadcast:<broadcast_id>.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+            scheduled_at: z.string().datetime(),
+            timezone: z.string().min(1).max(80),
+            confirmation_token: z
+                .string()
+                .optional()
+                .describe("Required: schedule_broadcast:<broadcast_id>. Obtain explicit user confirmation after reviewing counts and time."),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+        },
+    }, async ({ broadcast_id, scheduled_at, timezone, confirmation_token }) => {
+        const blocked = await requireBroadcastApproval("wabery_schedule_broadcast", `Schedule broadcast ${broadcast_id} for ${scheduled_at} (${timezone})?`, confirmation_token, `schedule_broadcast:${broadcast_id}`);
+        if (blocked)
+            return blocked;
+        return apiResult(client.post(`/broadcasts/${broadcast_id}/schedule`, {
+            scheduledAt: scheduled_at,
+            timezone,
+        }));
+    });
+    registerTool("wabery_cancel_broadcast", {
+        title: "Cancel Wabery broadcast",
+        description: "Cancel a draft, ready, scheduled, or sending broadcast and stop recipients that have not been dispatched. Already accepted messages cannot be recalled. Requires confirmation_token cancel_broadcast:<broadcast_id>.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+            confirmation_token: z
+                .string()
+                .optional()
+                .describe("Required: cancel_broadcast:<broadcast_id>."),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false,
+        },
+    }, async ({ broadcast_id, confirmation_token }) => {
+        const blocked = await requireBroadcastApproval("wabery_cancel_broadcast", `Cancel broadcast ${broadcast_id}? Messages already accepted by WhatsApp cannot be recalled.`, confirmation_token, `cancel_broadcast:${broadcast_id}`);
+        if (blocked)
+            return blocked;
+        return apiResult(client.post(`/broadcasts/${broadcast_id}/cancel`));
+    });
+    registerTool("wabery_duplicate_broadcast", {
+        title: "Duplicate Wabery broadcast",
+        description: "Create a new draft with the source broadcast's channel, template variants, and parameter mappings. The recipient snapshot is not copied; prepare a new audience before sending.",
+        inputSchema: {
+            broadcast_id: z.string().min(1),
+        },
+        annotations: {
+            readOnlyHint: false,
+            destructiveHint: false,
+            idempotentHint: false,
+            openWorldHint: false,
+        },
+    }, async ({ broadcast_id }) => {
+        const blocked = await requireWrite("wabery_duplicate_broadcast");
+        if (blocked)
+            return blocked;
+        return apiResult(client.post(`/broadcasts/${broadcast_id}/duplicate`));
+    });
+    registerTool("wabery_list_conversations", {
         title: "List Wabery conversations",
         description: "List organization-scoped conversations for inbox, support, or analytics tooling.",
         inputSchema: {
@@ -1002,7 +1454,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         ...query,
         active: query.active === undefined ? undefined : String(query.active),
     })));
-    server.registerTool("wabery_get_conversation", {
+    registerTool("wabery_get_conversation", {
         title: "Get Wabery conversation",
         description: "Fetch one organization-scoped conversation by id.",
         inputSchema: {
@@ -1015,7 +1467,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ conversation_id }) => jsonResult(await client.get(`/conversations/${conversation_id}`)));
-    server.registerTool("wabery_list_conversation_messages", {
+    registerTool("wabery_list_conversation_messages", {
         title: "List Wabery conversation messages",
         description: "Fetch message history for a conversation. Cached inbound WhatsApp media includes short-lived Wabery signed URLs; expires_at is the retention deadline.",
         inputSchema: {
@@ -1031,7 +1483,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ conversation_id, ...query }) => jsonResult(await client.get(`/conversations/${conversation_id}/messages`, query)));
-    server.registerTool("wabery_send_message", {
+    registerTool("wabery_send_message", {
         title: "Send Wabery message",
         description: "Send a WhatsApp text, approved template, media, or interactive message. The body must match POST /messages and should include an idempotency_key for retries.",
         inputSchema: {
@@ -1039,17 +1491,17 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
         },
     }, async ({ body }) => {
-        const blocked = requireWrite("wabery_send_message");
+        const blocked = await requireWrite("wabery_send_message");
         if (blocked)
             return blocked;
         return apiResult(client.post("/messages", body));
     });
-    server.registerTool("wabery_get_message", {
+    registerTool("wabery_get_message", {
         title: "Get Wabery message",
         description: "Fetch one message by message_id to inspect queued/provider status, delivery state, and Meta failure details after wabery_send_message.",
         inputSchema: {
@@ -1062,7 +1514,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ message_id }) => jsonResult(await client.get(`/messages/${message_id}`)));
-    server.registerTool("wabery_list_templates", {
+    registerTool("wabery_list_templates", {
         title: "List WhatsApp templates",
         description: "List WhatsApp message templates and approval statuses for dedicated WhatsApp channels.",
         inputSchema: {
@@ -1076,7 +1528,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async (query) => jsonResult(await client.get("/templates", query)));
-    server.registerTool("wabery_get_template", {
+    registerTool("wabery_get_template", {
         title: "Get WhatsApp template",
         description: "Fetch one WhatsApp template and its Meta approval status. Set refresh=true to force a live Meta status check.",
         inputSchema: {
@@ -1092,7 +1544,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
     }, async ({ template_id, refresh }) => jsonResult(await client.get(`/templates/${template_id}`, {
         refresh: refresh ? "true" : undefined,
     })));
-    server.registerTool("wabery_create_template", {
+    registerTool("wabery_create_template", {
         title: "Create WhatsApp template",
         description: "Create and submit a WhatsApp message template to Meta for approval. Only dedicated, non-sandbox WhatsApp channels with Meta-verified business accounts and a Meta payment method can submit templates. Check channel publish_readiness first.",
         inputSchema: {
@@ -1105,12 +1557,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: true,
         },
     }, async ({ body }) => {
-        const blocked = requireWrite("wabery_create_template");
+        const blocked = await requireWrite("wabery_create_template");
         if (blocked)
             return blocked;
         return apiResult(client.post("/templates", body));
     });
-    server.registerTool("wabery_wait_template", {
+    registerTool("wabery_wait_template", {
         title: "Wait for WhatsApp template approval",
         description: "Poll a WhatsApp template until Meta reports APPROVED. Fails if Meta rejects/disables it or if timeout_seconds elapses.",
         inputSchema: {
@@ -1128,7 +1580,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         timeoutMs: (timeout_seconds ?? 86_400) * 1000,
         intervalMs: (interval_seconds ?? 60) * 1000,
     })));
-    server.registerTool("wabery_send_flow", {
+    registerTool("wabery_send_flow", {
         title: "Send Wabery flow",
         description: "Send a published WhatsApp Flow to an enrolled contact, existing conversation, or phone number. Returns flow_token and dispatch info.",
         inputSchema: {
@@ -1146,17 +1598,17 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
         annotations: {
             readOnlyHint: false,
-            destructiveHint: false,
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: true,
         },
     }, async ({ flow_id, ...body }) => {
-        const blocked = requireWrite("wabery_send_flow");
+        const blocked = await requireWrite("wabery_send_flow");
         if (blocked)
             return blocked;
         return apiResult(client.post(`/flows/${flow_id}/send`, body));
     });
-    server.registerTool("wabery_list_submissions", {
+    registerTool("wabery_list_submissions", {
         title: "List Wabery submissions",
         description: "List completed WhatsApp Flow submissions for the organization.",
         inputSchema: {
@@ -1172,7 +1624,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async (query) => jsonResult(await client.get("/submissions", query)));
-    server.registerTool("wabery_list_dispatches", {
+    registerTool("wabery_list_dispatches", {
         title: "List Wabery dispatches",
         description: "List sent flow dispatches. Use this to inspect flow_token status across sends.",
         inputSchema: {
@@ -1189,7 +1641,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async (query) => jsonResult(await client.get("/dispatches", query)));
-    server.registerTool("wabery_get_dispatch", {
+    registerTool("wabery_get_dispatch", {
         title: "Get Wabery dispatch",
         description: "Get one flow dispatch by flow_token.",
         inputSchema: {
@@ -1203,7 +1655,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async ({ flow_token }) => jsonResult(await client.get(`/dispatches/${flow_token}`)));
     // ─── Hosted functions (serverless logic the agent authors) ───────────
-    server.registerTool("wabery_list_functions", {
+    registerTool("wabery_list_functions", {
         title: "List hosted functions",
         description: "List the project's hosted functions (serverless handlers that run on send/tool triggers).",
         inputSchema: {},
@@ -1214,7 +1666,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async () => jsonResult(await client.get("/functions")));
-    server.registerTool("wabery_get_function", {
+    registerTool("wabery_get_function", {
         title: "Get a hosted function",
         description: "Fetch one hosted function including its current source.",
         inputSchema: { function_id: z.string().min(1) },
@@ -1225,7 +1677,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ function_id }) => jsonResult(await client.get(`/functions/${function_id}`)));
-    server.registerTool("wabery_create_function", {
+    registerTool("wabery_create_function", {
         title: "Create a hosted function",
         description: "Create a hosted function (metadata only). Deploy source separately with wabery_deploy_function. trigger_type is an AutomationTriggerType, e.g. KEYWORD, WELCOME, ANY_MESSAGE.",
         inputSchema: {
@@ -1249,12 +1701,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_create_function", confirmation_token, "create_function");
+        const blocked = await requireWrite("wabery_create_function", confirmation_token, "create_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.post("/functions", body));
     });
-    server.registerTool("wabery_deploy_function", {
+    registerTool("wabery_deploy_function", {
         title: "Deploy a hosted function",
         description: "Bundle and upload TypeScript source for a hosted function. Returns { status, version_id?, diagnostics? } — read diagnostics on error, fix, and redeploy.",
         inputSchema: {
@@ -1272,12 +1724,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ function_id, source, confirmation_token }) => {
-        const blocked = requireWrite("wabery_deploy_function", confirmation_token, "deploy_function");
+        const blocked = await requireWrite("wabery_deploy_function", confirmation_token, "deploy_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.post(`/functions/${function_id}/deploy`, { source }));
     });
-    server.registerTool("wabery_test_function", {
+    registerTool("wabery_test_function", {
         title: "Test a hosted function",
         description: "Invoke a hosted function with a sample message event (no real send) and return its result plus logs.",
         inputSchema: {
@@ -1295,12 +1747,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ function_id, text, confirmation_token }) => {
-        const blocked = requireWrite("wabery_test_function", confirmation_token, "test_function");
+        const blocked = await requireWrite("wabery_test_function", confirmation_token, "test_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.post(`/functions/${function_id}/test`, { text }));
     });
-    server.registerTool("wabery_tail_function_logs", {
+    registerTool("wabery_tail_function_logs", {
         title: "Tail hosted function logs",
         description: "Recent invocations of a hosted function (status, cpu, error, captured logs) for debugging.",
         inputSchema: { function_id: z.string().min(1) },
@@ -1311,7 +1763,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ function_id }) => jsonResult(await client.get(`/functions/${function_id}/logs`)));
-    server.registerTool("wabery_delete_function", {
+    registerTool("wabery_delete_function", {
         title: "Delete a hosted function",
         description: "Delete a hosted function and its deployed Worker.",
         inputSchema: {
@@ -1328,12 +1780,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: false,
         },
     }, async ({ function_id, confirmation_token }) => {
-        const blocked = requireWrite("wabery_delete_function", confirmation_token, "delete_function");
+        const blocked = await requireWrite("wabery_delete_function", confirmation_token, "delete_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.delete(`/functions/${function_id}`));
     });
-    server.registerTool("wabery_update_function", {
+    registerTool("wabery_update_function", {
         title: "Update a hosted function",
         description: "Update a hosted function: rename, set expose_as_mcp_tool (make it callable by external agents), toggle is_active, or set input_schema (the tool schema used for agent/MCP calls).",
         inputSchema: {
@@ -1355,12 +1807,12 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
         },
     }, async (input) => {
         const { function_id, confirmation_token, ...body } = input;
-        const blocked = requireWrite("wabery_update_function", confirmation_token, "update_function");
+        const blocked = await requireWrite("wabery_update_function", confirmation_token, "update_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.patch(`/functions/${function_id}`, body));
     });
-    server.registerTool("wabery_invoke_function", {
+    registerTool("wabery_invoke_function", {
         title: "Invoke a hosted function as a tool",
         description: "Call a hosted function as a tool (mcp_call) with structured arguments and return its result. Optionally target a specific contact.",
         inputSchema: {
@@ -1379,7 +1831,7 @@ export function createWaberyMcpServer(client = new WaberyApiClient(), options =
             openWorldHint: true,
         },
     }, async ({ function_id, arguments: args, contact_id, confirmation_token, }) => {
-        const blocked = requireWrite("wabery_invoke_function", confirmation_token, "invoke_function");
+        const blocked = await requireWrite("wabery_invoke_function", confirmation_token, "invoke_function");
         if (blocked)
             return blocked;
         return jsonResult(await client.post(`/functions/${function_id}/invoke`, {