@daisyintel/whatsapp-cloud-mcp 0.1.0

package/dist/src/tools.js

@@ -0,0 +1,1187 @@
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { z } from "zod";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function ensureValue(value, envName) {
+    if (!value) {
+        throw new Error(`${envName} is required for this operation.`);
+    }
+    return value;
+}
+function resolvePhoneNumberId(config, override) {
+    return ensureValue(override ?? config.phoneNumberId, "WHATSAPP_PHONE_NUMBER_ID");
+}
+function resolveWabaId(config, override) {
+    return ensureValue(override ?? config.wabaId, "WHATSAPP_WABA_ID");
+}
+function resolveBusinessId(config, override) {
+    return ensureValue(override ?? config.businessId, "WHATSAPP_BUSINESS_ID");
+}
+function extractMessageIds(payload) {
+    if (typeof payload !== "object" || payload === null) {
+        return [];
+    }
+    const messages = payload.messages;
+    if (!Array.isArray(messages)) {
+        return [];
+    }
+    return messages
+        .map((message) => (typeof message === "object" && message !== null ? message.id : null))
+        .filter((id) => typeof id === "string");
+}
+function formatToolResult(result) {
+    if (result.ok) {
+        return {
+            endpoint: result.endpoint,
+            request_ids: extractMessageIds(result.data),
+            payload: result.data
+        };
+    }
+    return {
+        endpoint: result.endpoint,
+        error: {
+            status: result.status,
+            request_id: result.requestId,
+            ...result.error
+        }
+    };
+}
+function withContext(base, contextMessageId) {
+    if (!contextMessageId) {
+        return base;
+    }
+    return {
+        ...base,
+        context: {
+            message_id: contextMessageId
+        }
+    };
+}
+function buildBlockUsers(users) {
+    if (users.length === 0) {
+        throw new Error("At least one user is required.");
+    }
+    return users.map((user) => ({ user }));
+}
+function defaultBusinessProfileFields(fields) {
+    if (fields && fields.length > 0) {
+        return fields.join(",");
+    }
+    return "about,address,description,email,profile_picture_url,websites,vertical";
+}
+export function createToolHandlers(client, config, eventStore) {
+    return {
+        async getOwnedWabas(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolveBusinessId(config, args.business_id)}/owned_whatsapp_business_accounts`
+            }));
+        },
+        async getWaba(args) {
+            return formatToolResult(await client.safeRequest({
+                path: resolveWabaId(config, args.waba_id)
+            }));
+        },
+        async getPhoneNumbers(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolveWabaId(config, args.waba_id)}/phone_numbers`
+            }));
+        },
+        async registerPhoneNumber(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/register`,
+                body: {
+                    messaging_product: "whatsapp",
+                    pin: args.pin
+                }
+            }));
+        },
+        async requestVerificationCode(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/request_code`,
+                body: {
+                    code_method: args.code_method,
+                    locale: args.locale
+                }
+            }));
+        },
+        async verifyCode(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/verify_code`,
+                body: {
+                    code: args.code
+                }
+            }));
+        },
+        async subscribeApp(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolveWabaId(config, args.waba_id)}/subscribed_apps`
+            }));
+        },
+        async getSubscribedApps(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolveWabaId(config, args.waba_id)}/subscribed_apps`
+            }));
+        },
+        async unsubscribeApp(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "DELETE",
+                path: `${resolveWabaId(config, args.waba_id)}/subscribed_apps`
+            }));
+        },
+        async debugAccessToken() {
+            return formatToolResult(await client.safeRequest({
+                path: "debug_token",
+                query: {
+                    input_token: config.accessToken
+                }
+            }));
+        },
+        async getBusinessProfile(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/whatsapp_business_profile`,
+                query: {
+                    fields: defaultBusinessProfileFields(args.fields)
+                }
+            }));
+        },
+        async updateBusinessProfile(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/whatsapp_business_profile`,
+                body: {
+                    messaging_product: "whatsapp",
+                    ...(args.address !== undefined ? { address: args.address } : {}),
+                    ...(args.description !== undefined ? { description: args.description } : {}),
+                    ...(args.vertical !== undefined ? { vertical: args.vertical } : {}),
+                    ...(args.about !== undefined ? { about: args.about } : {}),
+                    ...(args.email !== undefined ? { email: args.email } : {}),
+                    ...(args.websites !== undefined ? { websites: args.websites } : {}),
+                    ...(args.profile_picture_handle !== undefined ? { profile_picture_handle: args.profile_picture_handle } : {})
+                }
+            }));
+        },
+        async getBlockedUsers(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/block_users`
+            }));
+        },
+        async blockUsers(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/block_users`,
+                body: {
+                    messaging_product: "whatsapp",
+                    block_users: buildBlockUsers(args.users)
+                }
+            }));
+        },
+        async unblockUsers(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "DELETE",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/block_users`,
+                body: {
+                    messaging_product: "whatsapp",
+                    block_users: buildBlockUsers(args.users)
+                }
+            }));
+        },
+        async getTemplates(args) {
+            return formatToolResult(await client.safeRequest({
+                path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+                query: {
+                    ...(args.limit !== undefined ? { limit: args.limit } : {}),
+                    ...(args.name ? { name: args.name } : {}),
+                    ...(args.fields && args.fields.length > 0 ? { fields: args.fields.join(",") } : {})
+                }
+            }));
+        },
+        async getTemplateById(args) {
+            return formatToolResult(await client.safeRequest({
+                path: args.template_id,
+                query: {
+                    ...(args.fields && args.fields.length > 0 ? { fields: args.fields.join(",") } : {})
+                }
+            }));
+        },
+        async createTemplate(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+                body: {
+                    name: args.name,
+                    language: args.language,
+                    category: args.category,
+                    components: args.components,
+                    ...(args.allow_category_change !== undefined ? { allow_category_change: args.allow_category_change } : {})
+                }
+            }));
+        },
+        async deleteTemplateByName(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "DELETE",
+                path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+                query: {
+                    name: args.name
+                }
+            }));
+        },
+        async sendTextMessage(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+                body: withContext({
+                    messaging_product: "whatsapp",
+                    recipient_type: "individual",
+                    to: args.to,
+                    type: "text",
+                    text: {
+                        body: args.body,
+                        preview_url: args.preview_url ?? false
+                    }
+                }, args.context_message_id)
+            }));
+        },
+        async sendTemplateMessage(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+                body: withContext({
+                    messaging_product: "whatsapp",
+                    recipient_type: "individual",
+                    to: args.to,
+                    type: "template",
+                    template: {
+                        name: args.name,
+                        language: {
+                            code: args.languageCode
+                        },
+                        ...(args.components ? { components: args.components } : {})
+                    }
+                }, args.contextMessageId)
+            }));
+        },
+        async sendMediaMessage(args) {
+            if (!args.media_id && !args.link) {
+                throw new Error("Either media_id or link is required.");
+            }
+            const mediaPayload = {};
+            if (args.media_id) {
+                mediaPayload.id = args.media_id;
+            }
+            if (args.link) {
+                mediaPayload.link = args.link;
+            }
+            if (args.caption && (args.media_type === "image" || args.media_type === "document" || args.media_type === "video")) {
+                mediaPayload.caption = args.caption;
+            }
+            if (args.filename && args.media_type === "document") {
+                mediaPayload.filename = args.filename;
+            }
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+                body: withContext({
+                    messaging_product: "whatsapp",
+                    recipient_type: "individual",
+                    to: args.to,
+                    type: args.media_type,
+                    [args.media_type]: mediaPayload
+                }, args.context_message_id)
+            }));
+        },
+        async sendRawMessage(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+                body: args.body
+            }));
+        },
+        async markMessageAsRead(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+                body: {
+                    messaging_product: "whatsapp",
+                    status: "read",
+                    message_id: args.message_id
+                }
+            }));
+        },
+        async uploadMedia(args) {
+            const fileBuffer = await readFile(args.file_path);
+            const formData = new FormData();
+            formData.append("messaging_product", "whatsapp");
+            formData.append("type", args.mime_type);
+            formData.append("file", new Blob([fileBuffer], { type: args.mime_type }), args.filename ?? basename(args.file_path));
+            return formatToolResult(await client.safeRequest({
+                method: "POST",
+                path: `${resolvePhoneNumberId(config, args.phone_number_id)}/media`,
+                formData
+            }));
+        },
+        async getMediaUrl(args) {
+            return formatToolResult(await client.safeRequest({
+                path: args.media_id
+            }));
+        },
+        async deleteMedia(args) {
+            return formatToolResult(await client.safeRequest({
+                method: "DELETE",
+                path: args.media_id,
+                query: {
+                    ...(args.phone_number_id ? { phone_number_id: args.phone_number_id } : {})
+                }
+            }));
+        },
+        async getRecentWebhookEvents(args) {
+            return {
+                payload: {
+                    events: eventStore.list(args.limit ?? 20)
+                }
+            };
+        }
+    };
+}
+function toToolResult(result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result, null, 2)
+            }
+        ],
+        structuredContent: result
+    };
+}
+export function registerWhatsAppTools(server, client, config, eventStore) {
+    const handlers = createToolHandlers(client, config, eventStore);
+    server.tool("whatsapp_get_owned_wabas", "List WhatsApp Business Accounts owned by the configured business.", {
+        business_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.getOwnedWabas(args)));
+    server.tool("whatsapp_get_waba", "Fetch metadata for a WhatsApp Business Account.", {
+        waba_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.getWaba(args)));
+    server.tool("whatsapp_get_phone_numbers", "List phone numbers attached to a WhatsApp Business Account.", {
+        waba_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.getPhoneNumbers(args)));
+    server.tool("whatsapp_register_phone_number", "Register a WhatsApp phone number and set the 6-digit verification PIN.", {
+        phone_number_id: z.string().optional(),
+        pin: z.string().regex(/^\d{6}$/)
+    }, async (args) => toToolResult(await handlers.registerPhoneNumber(args)));
+    server.tool("whatsapp_request_verification_code", "Request an SMS or voice verification code for a phone number.", {
+        phone_number_id: z.string().optional(),
+        code_method: z.enum(["SMS", "VOICE"]),
+        locale: z.string()
+    }, async (args) => toToolResult(await handlers.requestVerificationCode(args)));
+    server.tool("whatsapp_verify_code", "Verify a phone number using a previously requested code.", {
+        phone_number_id: z.string().optional(),
+        code: z.string().min(1)
+    }, async (args) => toToolResult(await handlers.verifyCode(args)));
+    server.tool("whatsapp_get_subscribed_apps", "List apps subscribed to the configured WABA webhooks.", {
+        waba_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.getSubscribedApps(args)));
+    server.tool("whatsapp_subscribe_app", "Subscribe the current app to receive webhook events for the configured WABA.", {
+        waba_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.subscribeApp(args)));
+    server.tool("whatsapp_unsubscribe_app", "Unsubscribe the current app from the configured WABA webhooks.", {
+        waba_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.unsubscribeApp(args)));
+    server.tool("whatsapp_debug_access_token", "Debug the configured access token using Graph API token introspection.", {}, async () => toToolResult(await handlers.debugAccessToken()));
+    server.tool("whatsapp_get_business_profile", "Fetch the WhatsApp business profile for a phone number.", {
+        phone_number_id: z.string().optional(),
+        fields: z.array(z.string()).optional()
+    }, async (args) => toToolResult(await handlers.getBusinessProfile(args)));
+    server.tool("whatsapp_update_business_profile", "Update the WhatsApp business profile for a phone number.", {
+        phone_number_id: z.string().optional(),
+        address: z.string().optional(),
+        description: z.string().optional(),
+        vertical: z.string().optional(),
+        about: z.string().optional(),
+        email: z.string().email().optional(),
+        websites: z.array(z.string().url()).max(2).optional(),
+        profile_picture_handle: z.string().optional()
+    }, async (args) => toToolResult(await handlers.updateBusinessProfile(args)));
+    server.tool("whatsapp_get_blocked_users", "List WhatsApp users blocked by the business phone number.", {
+        phone_number_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.getBlockedUsers(args)));
+    server.tool("whatsapp_block_users", "Block one or more WhatsApp users.", {
+        phone_number_id: z.string().optional(),
+        users: z.array(z.string()).min(1)
+    }, async (args) => toToolResult(await handlers.blockUsers(args)));
+    server.tool("whatsapp_unblock_users", "Unblock one or more WhatsApp users.", {
+        phone_number_id: z.string().optional(),
+        users: z.array(z.string()).min(1)
+    }, async (args) => toToolResult(await handlers.unblockUsers(args)));
+    server.tool("whatsapp_get_templates", "List message templates for the configured WABA.", {
+        waba_id: z.string().optional(),
+        limit: z.number().int().positive().optional(),
+        name: z.string().optional(),
+        fields: z.array(z.string()).optional()
+    }, async (args) => toToolResult(await handlers.getTemplates(args)));
+    server.tool("whatsapp_get_template_by_id", "Fetch a message template by template ID.", {
+        template_id: z.string(),
+        fields: z.array(z.string()).optional()
+    }, async (args) => toToolResult(await handlers.getTemplateById(args)));
+    server.tool("whatsapp_create_template", "Create a WhatsApp message template with a generic components payload.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => toToolResult(await handlers.createTemplate(args)));
+    server.tool("whatsapp_delete_template_by_name", "Delete a WhatsApp message template by name.", {
+        waba_id: z.string().optional(),
+        name: z.string()
+    }, async (args) => toToolResult(await handlers.deleteTemplateByName(args)));
+    server.tool("whatsapp_send_text_message", "Send a plain text WhatsApp message.", {
+        to: z.string(),
+        body: z.string().min(1),
+        phone_number_id: z.string().optional(),
+        preview_url: z.boolean().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.sendTextMessage(args)));
+    server.tool("whatsapp_send_template_message", "Send a template WhatsApp message.", {
+        to: z.string(),
+        name: z.string(),
+        languageCode: z.string(),
+        components: z.array(z.custom()).optional(),
+        phone_number_id: z.string().optional(),
+        previewUrl: z.boolean().optional(),
+        contextMessageId: z.string().optional()
+    }, async (args) => toToolResult(await handlers.sendTemplateMessage(args)));
+    server.tool("whatsapp_send_media_message", "Send an image, document, audio, sticker, or video message.", {
+        to: z.string(),
+        media_type: z.enum(["audio", "document", "image", "sticker", "video"]),
+        media_id: z.string().optional(),
+        link: z.string().url().optional(),
+        caption: z.string().optional(),
+        filename: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.sendMediaMessage(args)));
+    server.tool("whatsapp_send_raw_message", "Send a raw WhatsApp Cloud API message body for unsupported message variants.", {
+        phone_number_id: z.string().optional(),
+        body: z.record(z.string(), z.any())
+    }, async (args) => toToolResult(await handlers.sendRawMessage(args)));
+    server.tool("whatsapp_mark_message_as_read", "Mark a WhatsApp message as read.", {
+        message_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.markMessageAsRead(args)));
+    server.tool("whatsapp_upload_media", "Upload a local media file to WhatsApp Cloud API for later reuse.", {
+        file_path: z.string(),
+        mime_type: z.string(),
+        phone_number_id: z.string().optional(),
+        filename: z.string().optional()
+    }, async (args) => toToolResult(await handlers.uploadMedia(args)));
+    server.tool("whatsapp_get_media_url", "Fetch metadata and download URL for an uploaded WhatsApp media asset.", {
+        media_id: z.string()
+    }, async (args) => toToolResult(await handlers.getMediaUrl(args)));
+    server.tool("whatsapp_delete_media", "Delete an uploaded WhatsApp media asset.", {
+        media_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => toToolResult(await handlers.deleteMedia(args)));
+    server.tool("whatsapp_get_recent_webhook_events", "Return recently received inbound messages and delivery status events kept in memory.", {
+        limit: z.number().int().positive().max(100).optional()
+    }, async (args) => toToolResult(await handlers.getRecentWebhookEvents(args)));
+}
+function registerAdditionalWhatsAppTools(server, client, config) {
+    const rawRequest = async (request) => toToolResult(formatToolResult(await client.safeRequest(request)));
+    const sendMessage = async (args) => rawRequest({
+        method: "POST",
+        path: `${resolvePhoneNumberId(config, args.phone_number_id)}/messages`,
+        body: withContext(args.body, args.context_message_id)
+    });
+    const createTemplate = async (args) => rawRequest({
+        method: "POST",
+        path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+        body: {
+            name: args.name,
+            language: args.language,
+            category: args.category,
+            components: args.components,
+            ...(args.allow_category_change !== undefined ? { allow_category_change: args.allow_category_change } : {})
+        }
+    });
+    server.tool("whatsapp_get_shared_wabas", "List WhatsApp Business Accounts shared with the configured business.", {
+        business_id: z.string().optional()
+    }, async (args) => rawRequest({
+        path: `${resolveBusinessId(config, args.business_id)}/client_whatsapp_business_accounts`
+    }));
+    server.tool("whatsapp_deregister_phone", "Deregister a previously registered phone number.", {
+        phone_number_id: z.string().optional()
+    }, async (args) => rawRequest({
+        method: "POST",
+        path: `${resolvePhoneNumberId(config, args.phone_number_id)}/deregister`
+    }));
+    server.tool("whatsapp_get_phone_number_by_id", "Fetch a single business phone number by phone number ID.", {
+        phone_number_id: z.string().optional(),
+        fields: z.array(z.string()).optional()
+    }, async (args) => rawRequest({
+        path: resolvePhoneNumberId(config, args.phone_number_id),
+        query: args.fields && args.fields.length > 0 ? { fields: args.fields.join(",") } : undefined
+    }));
+    server.tool("whatsapp_get_display_name_status", "Fetch the beta display-name approval status for a phone number.", {
+        phone_number_id: z.string().optional()
+    }, async (args) => rawRequest({
+        path: resolvePhoneNumberId(config, args.phone_number_id),
+        query: {
+            fields: "name_status"
+        }
+    }));
+    server.tool("whatsapp_get_phone_numbers_with_filtering", "List WABA phone numbers using the filtering beta query parameters.", {
+        waba_id: z.string().optional(),
+        fields: z.string().optional(),
+        filtering: z.string().optional()
+    }, async (args) => rawRequest({
+        path: `${resolveWabaId(config, args.waba_id)}/phone_numbers`,
+        query: {
+            ...(args.fields ? { fields: args.fields } : {}),
+            ...(args.filtering ? { filtering: args.filtering } : {})
+        }
+    }));
+    server.tool("whatsapp_set_two_step_verification_code", "Change the two-step verification PIN for a phone number.", {
+        phone_number_id: z.string().optional(),
+        pin: z.string().regex(/^\d{6}$/)
+    }, async (args) => rawRequest({
+        method: "POST",
+        path: resolvePhoneNumberId(config, args.phone_number_id),
+        body: {
+            pin: args.pin
+        }
+    }));
+    server.tool("whatsapp_override_callback_url", "Subscribe a WABA with an override callback URL and verify token.", {
+        waba_id: z.string().optional(),
+        override_callback_uri: z.string().url(),
+        verify_token: z.string().min(1)
+    }, async (args) => rawRequest({
+        method: "POST",
+        path: `${resolveWabaId(config, args.waba_id)}/subscribed_apps`,
+        body: {
+            override_callback_uri: args.override_callback_uri,
+            verify_token: args.verify_token
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_text_message", "Send a text reply to a previously received WhatsApp message.", {
+        to: z.string(),
+        body: z.string().min(1),
+        context_message_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "text",
+            text: { body: args.body }
+        }
+    }));
+    server.tool("whatsapp_send_text_message_with_preview_url", "Send a text message with URL previews enabled.", {
+        to: z.string(),
+        body: z.string().min(1),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "text",
+            text: { body: args.body, preview_url: true }
+        }
+    }));
+    server.tool("whatsapp_send_reply_with_reaction_message", "Send a reaction reply to an existing WhatsApp message.", {
+        to: z.string(),
+        reaction_message_id: z.string(),
+        emoji: z.string().min(1),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "reaction",
+            reaction: {
+                message_id: args.reaction_message_id,
+                emoji: args.emoji
+            }
+        }
+    }));
+    server.tool("whatsapp_send_image_message_by_id", "Send an image message using an uploaded media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "image",
+            image: {
+                id: args.media_id,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_image_message_by_id", "Reply to a message with an uploaded image media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        context_message_id: z.string(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "image",
+            image: {
+                id: args.media_id,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_image_message_by_url", "Send an image message using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "image",
+            image: {
+                link: args.link,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_image_message_by_url", "Reply with an image using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        context_message_id: z.string(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "image",
+            image: {
+                link: args.link,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_audio_message_by_id", "Send an audio message using an uploaded media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "audio",
+            audio: { id: args.media_id }
+        }
+    }));
+    server.tool("whatsapp_send_audio_message_by_url", "Send an audio message using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "audio",
+            audio: { link: args.link }
+        }
+    }));
+    server.tool("whatsapp_send_video_message_by_id", "Send a video message using an uploaded media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "video",
+            video: {
+                id: args.media_id,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_video_message_by_url", "Send a video message using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        caption: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "video",
+            video: {
+                link: args.link,
+                ...(args.caption ? { caption: args.caption } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_document_message_by_id", "Send a document message using an uploaded media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        caption: z.string().optional(),
+        filename: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "document",
+            document: {
+                id: args.media_id,
+                ...(args.caption ? { caption: args.caption } : {}),
+                ...(args.filename ? { filename: args.filename } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_document_message_by_url", "Send a document message using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        caption: z.string().optional(),
+        filename: z.string().optional(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "document",
+            document: {
+                link: args.link,
+                ...(args.caption ? { caption: args.caption } : {}),
+                ...(args.filename ? { filename: args.filename } : {})
+            }
+        }
+    }));
+    server.tool("whatsapp_send_sticker_message_by_id", "Send a sticker message using an uploaded media ID.", {
+        to: z.string(),
+        media_id: z.string(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "sticker",
+            sticker: { id: args.media_id }
+        }
+    }));
+    server.tool("whatsapp_send_sticker_message_by_url", "Send a sticker message using a public URL.", {
+        to: z.string(),
+        link: z.string().url(),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "sticker",
+            sticker: { link: args.link }
+        }
+    }));
+    server.tool("whatsapp_send_contact_message", "Send a contact card message.", {
+        to: z.string(),
+        contacts: z.array(z.record(z.string(), z.any())).min(1),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "contacts",
+            contacts: args.contacts
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_contact_message", "Reply with a contact card message.", {
+        to: z.string(),
+        contacts: z.array(z.record(z.string(), z.any())).min(1),
+        context_message_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "contacts",
+            contacts: args.contacts
+        }
+    }));
+    server.tool("whatsapp_send_location_message", "Send a location message.", {
+        to: z.string(),
+        location: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "location",
+            location: args.location
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_location_message", "Reply with a location message.", {
+        to: z.string(),
+        location: z.record(z.string(), z.any()),
+        context_message_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "location",
+            location: args.location
+        }
+    }));
+    server.tool("whatsapp_send_message_template_text", "Send a template message using a text-oriented template payload.", {
+        to: z.string(),
+        template: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "template",
+            template: args.template
+        }
+    }));
+    server.tool("whatsapp_send_message_template_media", "Send a template message using a media-oriented template payload.", {
+        to: z.string(),
+        template: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "template",
+            template: args.template
+        }
+    }));
+    server.tool("whatsapp_send_message_template_interactive", "Send a template message using an interactive template payload.", {
+        to: z.string(),
+        template: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "template",
+            template: args.template
+        }
+    }));
+    server.tool("whatsapp_send_list_message", "Send an interactive list message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_reply_to_list_message", "Reply with an interactive list message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        context_message_id: z.string(),
+        phone_number_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_reply_button", "Send an interactive reply-button message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_single_product_message", "Send an interactive single-product message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_multi_product_message", "Send an interactive multi-product message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_catalog_message", "Send an interactive catalog message.", {
+        to: z.string(),
+        interactive: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "interactive",
+            interactive: args.interactive
+        }
+    }));
+    server.tool("whatsapp_send_catalog_template_message", "Send a template payload for a catalog-oriented template message.", {
+        to: z.string(),
+        template: z.record(z.string(), z.any()),
+        phone_number_id: z.string().optional(),
+        context_message_id: z.string().optional()
+    }, async (args) => sendMessage({
+        phone_number_id: args.phone_number_id,
+        context_message_id: args.context_message_id,
+        body: {
+            messaging_product: "whatsapp",
+            recipient_type: "individual",
+            to: args.to,
+            type: "template",
+            template: args.template
+        }
+    }));
+    server.tool("whatsapp_get_template_by_name_default_fields", "Fetch a template by name using the collection's default fields.", {
+        waba_id: z.string().optional(),
+        name: z.string()
+    }, async (args) => rawRequest({
+        path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+        query: { name: args.name }
+    }));
+    server.tool("whatsapp_get_all_templates_default_fields", "Fetch all templates using the collection's default fields.", {
+        waba_id: z.string().optional()
+    }, async (args) => rawRequest({
+        path: `${resolveWabaId(config, args.waba_id)}/message_templates`
+    }));
+    server.tool("whatsapp_get_namespace", "Fetch the message template namespace for a WABA.", {
+        waba_id: z.string().optional()
+    }, async (args) => rawRequest({
+        path: resolveWabaId(config, args.waba_id),
+        query: { fields: "message_template_namespace" }
+    }));
+    server.tool("whatsapp_create_auth_template_copy_code", "Create an authentication template with an OTP copy-code button payload.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_auth_template_one_tap_autofill", "Create an authentication template with an OTP one-tap autofill payload.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_catalog_template", "Create a catalog template payload.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_multi_product_template", "Create a multi-product template payload.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_template_text_header_quick_replies", "Create a template with text header, footer, and quick replies.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_template_image_header_cta", "Create a template with an image header and call-to-action buttons.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_template_location_header_website", "Create a template with a location header and website button.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_create_template_document_header_phone_url", "Create a template with a document header plus phone and URL buttons.", {
+        waba_id: z.string().optional(),
+        name: z.string(),
+        language: z.string(),
+        category: z.string(),
+        components: z.array(z.record(z.string(), z.any())),
+        allow_category_change: z.boolean().optional()
+    }, async (args) => createTemplate(args));
+    server.tool("whatsapp_edit_template", "Edit a template directly by template ID.", {
+        template_id: z.string(),
+        name: z.string().optional(),
+        components: z.array(z.record(z.string(), z.any())).optional()
+    }, async (args) => rawRequest({
+        method: "POST",
+        path: args.template_id,
+        body: {
+            ...(args.name ? { name: args.name } : {}),
+            ...(args.components ? { components: args.components } : {})
+        }
+    }));
+    server.tool("whatsapp_delete_template_by_id", "Delete a template by template ID and name.", {
+        waba_id: z.string().optional(),
+        hsm_id: z.string(),
+        name: z.string()
+    }, async (args) => rawRequest({
+        method: "DELETE",
+        path: `${resolveWabaId(config, args.waba_id)}/message_templates`,
+        query: {
+            hsm_id: args.hsm_id,
+            name: args.name
+        }
+    }));
+}
+export function createWhatsAppMcpServer(client, config, eventStore) {
+    const server = new McpServer({
+        name: "whatsapp-cloud-api",
+        version: "0.1.0"
+    });
+    registerWhatsAppTools(server, client, config, eventStore);
+    registerAdditionalWhatsAppTools(server, client, config);
+    return server;
+}
+//# sourceMappingURL=tools.js.map