@elizaos/plugin-whatsapp 2.0.0-alpha.5 → 2.0.0-alpha.7

package/dist/index.js

@@ -0,0 +1,1595 @@
+// src/index.ts
+import { EventEmitter as EventEmitter4 } from "node:events";
+
+// src/actions/sendMessage.ts
+import { composePromptFromState, ModelType, parseJSONObjectFromText } from "@elizaos/core";
+var WHATSAPP_SEND_MESSAGE_ACTION = "WHATSAPP_SEND_MESSAGE";
+var SEND_MESSAGE_TEMPLATE = `
+You are extracting WhatsApp message parameters from a conversation.
+
+The user wants to send a WhatsApp message. Extract the following:
+1. to: The phone number to send to (E.164 format, e.g., +14155552671)
+2. text: The message text to send
+
+{{recentMessages}}
+
+Based on the conversation, extract the message parameters.
+
+Respond with a JSON object:
+{
+  "to": "+14155552671",
+  "text": "Hello from WhatsApp!"
+}
+`;
+var sendMessageAction = {
+  name: WHATSAPP_SEND_MESSAGE_ACTION,
+  similes: ["SEND_WHATSAPP", "WHATSAPP_MESSAGE", "TEXT_WHATSAPP", "SEND_WHATSAPP_MESSAGE"],
+  description: "Send a text message via WhatsApp",
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["whatsapp", "send", "message"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = new RegExp("\\b(?:whatsapp|send|message)\\b", "i");
+    const __avRegexOk = __avRegex.test(__avText);
+    const __avSource = String(message?.content?.source ?? message?.source ?? "");
+    const __avExpectedSource = "whatsapp";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (_runtime, message2) => {
+      const source = message2.content?.source;
+      return source === "whatsapp";
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime, message, state, options));
+    } catch {
+      return false;
+    }
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const accessToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+    const phoneNumberId = runtime.getSetting("WHATSAPP_PHONE_NUMBER_ID");
+    const apiVersion = runtime.getSetting("WHATSAPP_API_VERSION") || "v24.0";
+    if (!accessToken || !phoneNumberId) {
+      if (callback) {
+        await callback({
+          text: "WhatsApp is not configured. Missing access token or phone number ID."
+        });
+      }
+      return { success: false, error: "WhatsApp not configured" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const prompt = composePromptFromState({
+      state: currentState,
+      template: SEND_MESSAGE_TEMPLATE
+    });
+    let params;
+    try {
+      const response = await runtime.useModel(ModelType.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText(response);
+      if (!parsed || !parsed.to || !parsed.text) {
+        const to = message.content?.from;
+        const text = currentState.values?.response?.toString() || "";
+        if (!to) {
+          if (callback) {
+            await callback({
+              text: "Could not determine who to send the message to"
+            });
+          }
+          return { success: false, error: "Missing recipient" };
+        }
+        if (!text || text.trim() === "") {
+          if (callback) {
+            await callback({
+              text: "Cannot send an empty message. Please provide message content."
+            });
+          }
+          return { success: false, error: "Empty message text" };
+        }
+        params = { to, text };
+      } else {
+        if (!parsed.text.trim()) {
+          if (callback) {
+            await callback({
+              text: "Cannot send an empty message. Please provide message content."
+            });
+          }
+          return { success: false, error: "Empty message text" };
+        }
+        params = parsed;
+      }
+    } catch {
+      if (callback) {
+        await callback({
+          text: "Failed to parse message parameters"
+        });
+      }
+      return { success: false, error: "Failed to parse message parameters" };
+    }
+    try {
+      const url = `https://graph.facebook.com/${apiVersion}/${phoneNumberId}/messages`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          messaging_product: "whatsapp",
+          recipient_type: "individual",
+          to: params.to,
+          type: "text",
+          text: {
+            preview_url: false,
+            body: params.text
+          }
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error?.message || `HTTP ${response.status}`);
+      }
+      const data = await response.json();
+      const messageId = data.messages?.[0]?.id;
+      if (callback) {
+        await callback({
+          text: `Message sent to ${params.to}`,
+          action: WHATSAPP_SEND_MESSAGE_ACTION
+        });
+      }
+      return {
+        success: true,
+        data: {
+          action: WHATSAPP_SEND_MESSAGE_ACTION,
+          to: params.to,
+          messageId
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (callback) {
+        await callback({
+          text: `Failed to send WhatsApp message: ${errorMessage}`
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "Send a WhatsApp message to +14155552671 saying hello"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll send that WhatsApp message now.",
+          actions: [WHATSAPP_SEND_MESSAGE_ACTION]
+        }
+      }
+    ]
+  ]
+};
+// src/actions/sendReaction.ts
+import { composePromptFromState as composePromptFromState2, ModelType as ModelType2, parseJSONObjectFromText as parseJSONObjectFromText2 } from "@elizaos/core";
+var WHATSAPP_SEND_REACTION_ACTION = "WHATSAPP_SEND_REACTION";
+var REACTION_TEMPLATE = `
+You are extracting WhatsApp reaction parameters from a conversation.
+
+The user wants to react to a WhatsApp message. Extract the following:
+1. messageId: The ID of the message to react to
+2. emoji: The emoji to use as a reaction
+
+{{recentMessages}}
+
+Based on the conversation, extract the reaction parameters.
+
+Respond with a JSON object:
+{
+  "messageId": "wamid.xxx",
+  "emoji": "\uD83D\uDC4D"
+}
+`;
+var sendReactionAction = {
+  name: WHATSAPP_SEND_REACTION_ACTION,
+  similes: ["WHATSAPP_REACT", "REACT_WHATSAPP", "WHATSAPP_EMOJI"],
+  description: "Send a reaction emoji to a WhatsApp message",
+  validate: async (runtime, message, state, options) => {
+    const __avTextRaw = typeof message?.content?.text === "string" ? message.content.text : "";
+    const __avText = __avTextRaw.toLowerCase();
+    const __avKeywords = ["whatsapp", "send", "reaction"];
+    const __avKeywordOk = __avKeywords.length > 0 && __avKeywords.some((kw) => kw.length > 0 && __avText.includes(kw));
+    const __avRegex = new RegExp("\\b(?:whatsapp|send|reaction)\\b", "i");
+    const __avRegexOk = __avRegex.test(__avText);
+    const __avSource = String(message?.content?.source ?? message?.source ?? "");
+    const __avExpectedSource = "whatsapp";
+    const __avSourceOk = __avExpectedSource ? __avSource === __avExpectedSource : Boolean(__avSource || state || runtime?.agentId || runtime?.getService);
+    const __avOptions = options && typeof options === "object" ? options : {};
+    const __avInputOk = __avText.trim().length > 0 || Object.keys(__avOptions).length > 0 || Boolean(message?.content && typeof message.content === "object");
+    if (!(__avKeywordOk && __avRegexOk && __avSourceOk && __avInputOk)) {
+      return false;
+    }
+    const __avLegacyValidate = async (_runtime, message2) => {
+      const source = message2.content?.source;
+      return source === "whatsapp";
+    };
+    try {
+      return Boolean(await __avLegacyValidate(runtime, message, state, options));
+    } catch {
+      return false;
+    }
+  },
+  handler: async (runtime, message, state, _options, callback) => {
+    const accessToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+    const phoneNumberId = runtime.getSetting("WHATSAPP_PHONE_NUMBER_ID");
+    const apiVersion = runtime.getSetting("WHATSAPP_API_VERSION") || "v24.0";
+    if (!accessToken || !phoneNumberId) {
+      if (callback) {
+        await callback({
+          text: "WhatsApp is not configured. Missing access token or phone number ID."
+        });
+      }
+      return { success: false, error: "WhatsApp not configured" };
+    }
+    const currentState = state ?? await runtime.composeState(message);
+    const prompt = composePromptFromState2({
+      state: currentState,
+      template: REACTION_TEMPLATE
+    });
+    let params;
+    try {
+      const response = await runtime.useModel(ModelType2.TEXT_SMALL, {
+        prompt
+      });
+      const parsed = parseJSONObjectFromText2(response);
+      if (!parsed || !parsed.messageId || !parsed.emoji) {
+        const messageId = message.content?.messageId;
+        if (!messageId) {
+          if (callback) {
+            await callback({
+              text: "Could not determine which message to react to"
+            });
+          }
+          return { success: false, error: "Missing message ID" };
+        }
+        params = { messageId, emoji: "\uD83D\uDC4D" };
+      } else {
+        params = parsed;
+      }
+    } catch {
+      if (callback) {
+        await callback({
+          text: "Failed to parse reaction parameters"
+        });
+      }
+      return { success: false, error: "Failed to parse reaction parameters" };
+    }
+    const to = message.content?.from;
+    if (!to) {
+      if (callback) {
+        await callback({
+          text: "Could not determine the recipient for the reaction"
+        });
+      }
+      return { success: false, error: "Missing recipient" };
+    }
+    try {
+      const url = `https://graph.facebook.com/${apiVersion}/${phoneNumberId}/messages`;
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${accessToken}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          messaging_product: "whatsapp",
+          recipient_type: "individual",
+          to,
+          type: "reaction",
+          reaction: {
+            message_id: params.messageId,
+            emoji: params.emoji
+          }
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json();
+        throw new Error(errorData.error?.message || `HTTP ${response.status}`);
+      }
+      if (callback) {
+        await callback({
+          text: `Reacted with ${params.emoji}`,
+          action: WHATSAPP_SEND_REACTION_ACTION
+        });
+      }
+      return {
+        success: true,
+        data: {
+          action: WHATSAPP_SEND_REACTION_ACTION,
+          messageId: params.messageId,
+          emoji: params.emoji
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (callback) {
+        await callback({
+          text: `Failed to send reaction: ${errorMessage}`
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "React with a thumbs up"
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I'll add that reaction.",
+          actions: [WHATSAPP_SEND_REACTION_ACTION]
+        }
+      }
+    ]
+  ]
+};
+// src/client.ts
+import axios from "axios";
+import { EventEmitter } from "node:events";
+var DEFAULT_API_VERSION = "v24.0";
+
+class WhatsAppClient extends EventEmitter {
+  client;
+  config;
+  connectionStatus = "close";
+  constructor(config) {
+    super();
+    this.config = config;
+    const apiVersion = config.apiVersion || DEFAULT_API_VERSION;
+    this.client = axios.create({
+      baseURL: `https://graph.facebook.com/${apiVersion}`,
+      headers: {
+        Authorization: `Bearer ${config.accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async start() {
+    this.connectionStatus = "open";
+    this.emit("connection", "open");
+    this.emit("ready");
+  }
+  async stop() {
+    this.connectionStatus = "close";
+    this.emit("connection", "close");
+  }
+  getConnectionStatus() {
+    return this.connectionStatus;
+  }
+  getPhoneNumberId() {
+    return this.config.phoneNumberId;
+  }
+  async sendMessage(message) {
+    const endpoint = `/${this.config.phoneNumberId}/messages`;
+    const payload = this.buildMessagePayload(message);
+    return this.client.post(endpoint, payload);
+  }
+  async sendTextMessage(to, text, _previewUrl = false) {
+    return this.sendMessage({
+      type: "text",
+      to,
+      content: text
+    });
+  }
+  async sendReaction(params) {
+    const endpoint = `/${this.config.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to: params.to,
+      type: "reaction",
+      reaction: {
+        message_id: params.messageId,
+        emoji: params.emoji
+      }
+    };
+    try {
+      const response = await this.client.post(endpoint, payload);
+      return {
+        success: true,
+        messageId: response.data.messages?.[0]?.id
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+  async removeReaction(to, messageId) {
+    return this.sendReaction({
+      to,
+      messageId,
+      emoji: ""
+    });
+  }
+  async sendImage(to, imageUrl, caption) {
+    return this.sendMessage({
+      type: "image",
+      to,
+      content: {
+        link: imageUrl,
+        caption
+      }
+    });
+  }
+  async sendVideo(to, videoUrl, caption) {
+    return this.sendMessage({
+      type: "video",
+      to,
+      content: {
+        link: videoUrl,
+        caption
+      }
+    });
+  }
+  async sendAudio(to, audioUrl) {
+    return this.sendMessage({
+      type: "audio",
+      to,
+      content: {
+        link: audioUrl
+      }
+    });
+  }
+  async sendDocument(to, documentUrl, filename, caption) {
+    return this.sendMessage({
+      type: "document",
+      to,
+      content: {
+        link: documentUrl,
+        filename,
+        caption
+      }
+    });
+  }
+  async sendLocation(to, latitude, longitude, name, address) {
+    return this.sendMessage({
+      type: "location",
+      to,
+      content: {
+        latitude,
+        longitude,
+        name,
+        address
+      }
+    });
+  }
+  async sendButtonMessage(to, bodyText, buttons, headerText, footerText) {
+    const interactive = {
+      type: "button",
+      body: { text: bodyText },
+      action: {
+        buttons: buttons.map((btn) => ({
+          type: "reply",
+          reply: { id: btn.id, title: btn.title }
+        }))
+      }
+    };
+    if (headerText) {
+      interactive.header = { type: "text", text: headerText };
+    }
+    if (footerText) {
+      interactive.footer = { text: footerText };
+    }
+    return this.sendMessage({
+      type: "interactive",
+      to,
+      content: interactive
+    });
+  }
+  async sendListMessage(to, bodyText, buttonText, sections, headerText, footerText) {
+    const interactive = {
+      type: "list",
+      body: { text: bodyText },
+      action: {
+        button: buttonText,
+        sections
+      }
+    };
+    if (headerText) {
+      interactive.header = { type: "text", text: headerText };
+    }
+    if (footerText) {
+      interactive.footer = { text: footerText };
+    }
+    return this.sendMessage({
+      type: "interactive",
+      to,
+      content: interactive
+    });
+  }
+  async markMessageAsRead(messageId) {
+    const endpoint = `/${this.config.phoneNumberId}/messages`;
+    const payload = {
+      messaging_product: "whatsapp",
+      status: "read",
+      message_id: messageId
+    };
+    try {
+      await this.client.post(endpoint, payload);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getMediaUrl(mediaId) {
+    try {
+      const response = await this.client.get(`/${mediaId}`);
+      return response.data.url || null;
+    } catch {
+      return null;
+    }
+  }
+  async verifyWebhook(token) {
+    return token === this.config.webhookVerifyToken;
+  }
+  buildMessagePayload(message) {
+    const basePayload = {
+      messaging_product: "whatsapp",
+      recipient_type: "individual",
+      to: message.to,
+      type: message.type
+    };
+    const contextPayload = message.replyToMessageId ? { context: { message_id: message.replyToMessageId } } : {};
+    switch (message.type) {
+      case "text":
+        return {
+          ...basePayload,
+          ...contextPayload,
+          text: {
+            body: message.content
+          }
+        };
+      case "template":
+        return {
+          ...basePayload,
+          ...contextPayload,
+          template: message.content
+        };
+      case "image": {
+        const imageContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          image: {
+            link: imageContent.link,
+            caption: imageContent.caption
+          }
+        };
+      }
+      case "video": {
+        const videoContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          video: {
+            link: videoContent.link,
+            caption: videoContent.caption
+          }
+        };
+      }
+      case "audio": {
+        const audioContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          audio: {
+            link: audioContent.link
+          }
+        };
+      }
+      case "document": {
+        const docContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          document: {
+            link: docContent.link,
+            filename: docContent.filename,
+            caption: docContent.caption
+          }
+        };
+      }
+      case "location": {
+        const locContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          location: {
+            latitude: locContent.latitude,
+            longitude: locContent.longitude,
+            name: locContent.name,
+            address: locContent.address
+          }
+        };
+      }
+      case "reaction": {
+        const reactionContent = message.content;
+        return {
+          ...basePayload,
+          reaction: {
+            message_id: reactionContent.messageId,
+            emoji: reactionContent.emoji
+          }
+        };
+      }
+      case "interactive": {
+        const interactiveContent = message.content;
+        return {
+          ...basePayload,
+          ...contextPayload,
+          interactive: interactiveContent
+        };
+      }
+      default:
+        return basePayload;
+    }
+  }
+}
+
+// src/utils/config-detector.ts
+function detectAuthMethod(config) {
+  const explicitMethod = config.authMethod;
+  if (explicitMethod !== undefined) {
+    if (explicitMethod === "baileys" || explicitMethod === "cloudapi") {
+      return explicitMethod;
+    }
+    throw new Error(`Invalid authMethod: "${String(explicitMethod)}". Must be either "baileys" or "cloudapi".`);
+  }
+  if ("authDir" in config && config.authDir) {
+    return "baileys";
+  }
+  if ("accessToken" in config && "phoneNumberId" in config) {
+    return "cloudapi";
+  }
+  throw new Error("Cannot detect auth method. Provide either authDir (Baileys) or accessToken + phoneNumberId (Cloud API).");
+}
+
+// src/clients/baileys-client.ts
+import { EventEmitter as EventEmitter3 } from "node:events";
+
+// src/baileys/auth.ts
+import { useMultiFileAuthState } from "@whiskeysockets/baileys";
+
+class BaileysAuthManager {
+  authDir;
+  state;
+  saveCreds;
+  constructor(authDir) {
+    this.authDir = authDir;
+  }
+  async initialize() {
+    const result = await useMultiFileAuthState(this.authDir);
+    this.state = result.state;
+    this.saveCreds = result.saveCreds;
+    return this.state;
+  }
+  async save() {
+    if (this.saveCreds) {
+      await this.saveCreds();
+    }
+  }
+}
+
+// src/baileys/connection.ts
+import makeWASocket, { DisconnectReason } from "@whiskeysockets/baileys";
+import { EventEmitter as EventEmitter2 } from "node:events";
+import pino from "pino";
+
+class BaileysConnection extends EventEmitter2 {
+  socket;
+  authManager;
+  connectionStatus = "close";
+  reconnecting = false;
+  reconnectAttempts = 0;
+  maxReconnectAttempts = 10;
+  constructor(authManager) {
+    super();
+    this.authManager = authManager;
+  }
+  async connect() {
+    this.connectionStatus = "connecting";
+    this.emit("connection", "connecting");
+    const state = await this.authManager.initialize();
+    this.socket = makeWASocket({
+      auth: state,
+      printQRInTerminal: false,
+      logger: pino({ level: "silent" }),
+      browser: ["Chrome (Linux)", "", ""]
+    });
+    this.setupEventHandlers();
+    return this.socket;
+  }
+  setupEventHandlers() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.ev.on("connection.update", async (update) => {
+      const { connection, qr, lastDisconnect } = update;
+      if (qr) {
+        this.emit("qr", qr);
+      }
+      if (connection) {
+        this.connectionStatus = connection;
+        this.emit("connection", connection);
+      }
+      if (connection === "open") {
+        this.reconnectAttempts = 0;
+        return;
+      }
+      if (connection !== "close") {
+        return;
+      }
+      const statusCode = lastDisconnect?.error?.output?.statusCode;
+      const isQRTimeout = statusCode === 515;
+      const shouldReconnect = statusCode !== DisconnectReason.loggedOut && statusCode !== 405;
+      if (lastDisconnect?.error && !isQRTimeout) {
+        this.emit("error", lastDisconnect.error);
+      }
+      if (!shouldReconnect) {
+        return;
+      }
+      if (this.reconnecting) {
+        return;
+      }
+      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+        this.emit("error", new Error("Max reconnection attempts reached"));
+        return;
+      }
+      this.reconnecting = true;
+      try {
+        this.reconnectAttempts += 1;
+        const baseDelayMs = isQRTimeout ? 1000 : 3000;
+        const backoffMs = Math.min(baseDelayMs * Math.pow(2, this.reconnectAttempts - 1), 30000);
+        await new Promise((resolve) => setTimeout(resolve, backoffMs));
+        await this.connect();
+      } catch (error) {
+        this.emit("error", error);
+      } finally {
+        this.reconnecting = false;
+      }
+    });
+    this.socket.ev.on("creds.update", async () => {
+      await this.authManager.save();
+    });
+    this.socket.ev.on("messages.upsert", ({ messages }) => {
+      this.emit("messages", messages);
+    });
+  }
+  getSocket() {
+    return this.socket;
+  }
+  getStatus() {
+    return this.connectionStatus;
+  }
+  async disconnect() {
+    if (!this.socket) {
+      return;
+    }
+    this.socket.ev.removeAllListeners();
+    this.socket.ws?.close?.();
+    this.socket = undefined;
+    this.connectionStatus = "close";
+    this.emit("connection", "close");
+  }
+}
+
+// src/baileys/message-adapter.ts
+class MessageAdapter {
+  toUnified(msg) {
+    return {
+      id: msg.key?.id ?? "",
+      from: msg.key?.remoteJid ?? "",
+      timestamp: Number(msg.messageTimestamp ?? 0),
+      type: this.detectType(msg),
+      content: this.extractContent(msg)
+    };
+  }
+  toBaileys(msg) {
+    switch (msg.type) {
+      case "text":
+        return { text: msg.content };
+      case "image":
+        return this.mediaWithCaption("image", msg.content);
+      case "video":
+        return this.mediaWithCaption("video", msg.content);
+      case "audio":
+        return this.mediaNoCaption("audio", msg.content);
+      case "document":
+        return this.mediaWithFilename(msg.content);
+      case "template":
+        return { text: this.renderTemplate(msg.content) };
+      default:
+        throw new Error(`Message type ${msg.type} is not yet supported for Baileys`);
+    }
+  }
+  mediaWithCaption(key, media) {
+    if (!media?.link) {
+      throw new Error(`${key} message requires a media link`);
+    }
+    return {
+      [key]: { url: media.link },
+      ...media.caption ? { caption: media.caption } : {}
+    };
+  }
+  mediaNoCaption(key, media) {
+    if (!media?.link) {
+      throw new Error(`${key} message requires a media link`);
+    }
+    return { [key]: { url: media.link } };
+  }
+  mediaWithFilename(media) {
+    if (!media?.link) {
+      throw new Error("document message requires a media link");
+    }
+    return {
+      document: { url: media.link },
+      ...media.filename ? { fileName: media.filename } : {},
+      ...media.caption ? { caption: media.caption } : {}
+    };
+  }
+  detectType(msg) {
+    if (msg.message?.conversation || msg.message?.extendedTextMessage) {
+      return "text";
+    }
+    if (msg.message?.imageMessage) {
+      return "image";
+    }
+    if (msg.message?.audioMessage) {
+      return "audio";
+    }
+    if (msg.message?.videoMessage) {
+      return "video";
+    }
+    if (msg.message?.documentMessage) {
+      return "document";
+    }
+    return "text";
+  }
+  extractContent(msg) {
+    return msg.message?.conversation ?? msg.message?.extendedTextMessage?.text ?? "";
+  }
+  renderTemplate(template) {
+    const params = template.components?.flatMap((component) => component.parameters.map((parameter) => parameter.text).filter(Boolean));
+    return params && params.length > 0 ? `${template.name}: ${params.join(", ")}` : template.name;
+  }
+}
+
+// src/baileys/qr-code.ts
+import QRCode from "qrcode";
+import QRCodeTerminal from "qrcode-terminal";
+
+class QRCodeGenerator {
+  async generate(qrString) {
+    return {
+      terminal: await this.generateTerminal(qrString),
+      dataURL: await QRCode.toDataURL(qrString),
+      raw: qrString
+    };
+  }
+  async generateTerminal(qr) {
+    return new Promise((resolve) => {
+      QRCodeTerminal.generate(qr, { small: true }, (output) => {
+        resolve(output);
+      });
+    });
+  }
+}
+
+// src/clients/baileys-client.ts
+class BaileysClient extends EventEmitter3 {
+  config;
+  authManager;
+  connection;
+  qrGenerator;
+  adapter;
+  constructor(config) {
+    super();
+    this.config = config;
+    this.authManager = new BaileysAuthManager(config.authDir);
+    this.connection = new BaileysConnection(this.authManager);
+    this.qrGenerator = new QRCodeGenerator;
+    this.adapter = new MessageAdapter;
+    this.setupEventForwarding();
+  }
+  setupEventForwarding() {
+    this.connection.on("qr", async (qr) => {
+      try {
+        const qrData = await this.qrGenerator.generate(qr);
+        if (this.config.printQRInTerminal !== false) {
+          console.log(`
+=== Scan QR Code ===
+`);
+          console.log(qrData.terminal);
+        }
+        this.emit("qr", qrData);
+      } catch (error) {
+        this.emit("error", error);
+      }
+    });
+    this.connection.on("connection", (status) => {
+      this.emit("connection", status);
+      if (status === "open") {
+        this.emit("ready");
+      }
+    });
+    this.connection.on("messages", (messages) => {
+      for (const message of messages) {
+        const maybe = message;
+        if (!maybe.key?.fromMe && maybe.message) {
+          this.emit("message", this.adapter.toUnified(message));
+        }
+      }
+    });
+    this.connection.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+  async start() {
+    await this.connection.connect();
+  }
+  async stop() {
+    await this.connection.disconnect();
+  }
+  async sendMessage(message) {
+    const socket = this.connection.getSocket();
+    if (!socket) {
+      throw new Error("Not connected to WhatsApp via Baileys");
+    }
+    const payload = this.adapter.toBaileys(message);
+    const result = await socket.sendMessage(message.to, payload);
+    const id = result?.key?.id ?? "";
+    return {
+      messaging_product: "whatsapp",
+      contacts: [{ input: message.to, wa_id: message.to }],
+      messages: [{ id }]
+    };
+  }
+  getConnectionStatus() {
+    return this.connection.getStatus();
+  }
+}
+
+// src/clients/factory.ts
+class ClientFactory {
+  static create(config) {
+    const authMethod = detectAuthMethod(config);
+    if (authMethod === "baileys") {
+      return new BaileysClient(config);
+    }
+    return new WhatsAppClient(config);
+  }
+}
+
+// src/handlers/message.handler.ts
+class MessageHandler {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async send(message) {
+    try {
+      const response = await this.client.sendMessage(message);
+      if (response && typeof response === "object" && "data" in response) {
+        return response.data;
+      }
+      return response;
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to send WhatsApp message: ${error.message}`);
+      }
+      throw new Error("Failed to send WhatsApp message");
+    }
+  }
+}
+// src/handlers/webhook.handler.ts
+class WebhookHandler {
+  async handle(event) {
+    try {
+      if (event.entry?.[0]?.changes?.[0]?.value?.messages) {
+        const messages = event.entry[0].changes[0].value.messages;
+        for (const message of messages) {
+          await this.handleMessage(message);
+        }
+      }
+      if (event.entry?.[0]?.changes?.[0]?.value?.statuses) {
+        const statuses = event.entry[0].changes[0].value.statuses;
+        for (const status of statuses) {
+          await this.handleStatus(status);
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Failed to send WhatsApp message: ${error.message}`);
+      }
+      throw new Error("Failed to send WhatsApp message");
+    }
+  }
+  async handleMessage(message) {
+    console.log("Received message:", message);
+  }
+  async handleStatus(status) {
+    console.log("Received status update:", status);
+  }
+}
+// src/accounts.ts
+import { checkPairingAllowed, isInAllowlist } from "@elizaos/core";
+var DEFAULT_ACCOUNT_ID = "default";
+function normalizeAccountId(accountId) {
+  if (!accountId || typeof accountId !== "string") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  const trimmed = accountId.trim().toLowerCase();
+  if (!trimmed || trimmed === "default") {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return trimmed;
+}
+function getMultiAccountConfig(runtime) {
+  const characterWhatsApp = runtime.character?.settings?.whatsapp;
+  return {
+    enabled: characterWhatsApp?.enabled,
+    accessToken: characterWhatsApp?.accessToken,
+    phoneNumberId: characterWhatsApp?.phoneNumberId,
+    businessAccountId: characterWhatsApp?.businessAccountId,
+    webhookVerifyToken: characterWhatsApp?.webhookVerifyToken,
+    apiVersion: characterWhatsApp?.apiVersion,
+    dmPolicy: characterWhatsApp?.dmPolicy,
+    groupPolicy: characterWhatsApp?.groupPolicy,
+    mediaMaxMb: characterWhatsApp?.mediaMaxMb,
+    textChunkLimit: characterWhatsApp?.textChunkLimit,
+    accounts: characterWhatsApp?.accounts,
+    groups: characterWhatsApp?.groups
+  };
+}
+function listWhatsAppAccountIds(runtime) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  const ids = new Set;
+  const envToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+  const envPhoneId = runtime.getSetting("WHATSAPP_PHONE_NUMBER_ID");
+  const baseConfigured = Boolean(config.accessToken?.trim() && config.phoneNumberId?.trim());
+  const envConfigured = Boolean(envToken?.trim() && envPhoneId?.trim());
+  if (baseConfigured || envConfigured) {
+    ids.add(DEFAULT_ACCOUNT_ID);
+  }
+  if (accounts && typeof accounts === "object") {
+    for (const id of Object.keys(accounts)) {
+      if (id) {
+        ids.add(normalizeAccountId(id));
+      }
+    }
+  }
+  const result = Array.from(ids);
+  if (result.length === 0) {
+    return [DEFAULT_ACCOUNT_ID];
+  }
+  return result.slice().sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultWhatsAppAccountId(runtime) {
+  const ids = listWhatsAppAccountIds(runtime);
+  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
+    return DEFAULT_ACCOUNT_ID;
+  }
+  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+}
+function getAccountConfig(runtime, accountId) {
+  const config = getMultiAccountConfig(runtime);
+  const accounts = config.accounts;
+  if (!accounts || typeof accounts !== "object") {
+    return;
+  }
+  const direct = accounts[accountId];
+  if (direct) {
+    return direct;
+  }
+  const normalized = normalizeAccountId(accountId);
+  const matchKey = Object.keys(accounts).find((key) => normalizeAccountId(key) === normalized);
+  return matchKey ? accounts[matchKey] : undefined;
+}
+function resolveWhatsAppToken(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const accountConfig = getAccountConfig(runtime, accountId);
+  if (accountConfig?.accessToken?.trim()) {
+    return { token: accountConfig.accessToken.trim(), source: "config" };
+  }
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    if (multiConfig.accessToken?.trim()) {
+      return { token: multiConfig.accessToken.trim(), source: "config" };
+    }
+    const envToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+    if (envToken?.trim()) {
+      return { token: envToken.trim(), source: "env" };
+    }
+  }
+  return { token: "", source: "none" };
+}
+function filterDefined(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function mergeWhatsAppAccountConfig(runtime, accountId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const { accounts: _ignored, ...baseConfig } = multiConfig;
+  const accountConfig = getAccountConfig(runtime, accountId) ?? {};
+  const envToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+  const envPhoneId = runtime.getSetting("WHATSAPP_PHONE_NUMBER_ID");
+  const envBusinessId = runtime.getSetting("WHATSAPP_BUSINESS_ACCOUNT_ID");
+  const envWebhookToken = runtime.getSetting("WHATSAPP_WEBHOOK_VERIFY_TOKEN");
+  const envDmPolicy = runtime.getSetting("WHATSAPP_DM_POLICY");
+  const envGroupPolicy = runtime.getSetting("WHATSAPP_GROUP_POLICY");
+  const envConfig = {
+    accessToken: envToken || undefined,
+    phoneNumberId: envPhoneId || undefined,
+    businessAccountId: envBusinessId || undefined,
+    webhookVerifyToken: envWebhookToken || undefined,
+    dmPolicy: envDmPolicy,
+    groupPolicy: envGroupPolicy
+  };
+  return {
+    ...filterDefined(envConfig),
+    ...filterDefined(baseConfig),
+    ...filterDefined(accountConfig)
+  };
+}
+function resolveWhatsAppAccount(runtime, accountId) {
+  const normalizedAccountId = normalizeAccountId(accountId);
+  const multiConfig = getMultiAccountConfig(runtime);
+  const baseEnabled = multiConfig.enabled !== false;
+  const merged = mergeWhatsAppAccountConfig(runtime, normalizedAccountId);
+  const accountEnabled = merged.enabled !== false;
+  const enabled = baseEnabled && accountEnabled;
+  const { token, source: tokenSource } = resolveWhatsAppToken(runtime, normalizedAccountId);
+  const phoneNumberId = merged.phoneNumberId?.trim() || "";
+  const configured = Boolean(token && phoneNumberId);
+  return {
+    accountId: normalizedAccountId,
+    enabled,
+    name: merged.name?.trim() || undefined,
+    accessToken: token,
+    phoneNumberId,
+    businessAccountId: merged.businessAccountId?.trim() || undefined,
+    tokenSource,
+    configured,
+    config: merged
+  };
+}
+function listEnabledWhatsAppAccounts(runtime) {
+  return listWhatsAppAccountIds(runtime).map((accountId) => resolveWhatsAppAccount(runtime, accountId)).filter((account) => account.enabled && account.configured);
+}
+function isMultiAccountEnabled(runtime) {
+  const accounts = listEnabledWhatsAppAccounts(runtime);
+  return accounts.length > 1;
+}
+function resolveWhatsAppGroupConfig(runtime, accountId, groupId) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const accountConfig = getAccountConfig(runtime, accountId);
+  const accountGroup = accountConfig?.groups?.[groupId];
+  if (accountGroup) {
+    return accountGroup;
+  }
+  return multiConfig.groups?.[groupId];
+}
+function isWhatsAppUserAllowed(params) {
+  const { identifier, accountConfig, isGroup, groupConfig } = params;
+  if (isGroup) {
+    const policy2 = accountConfig.groupPolicy ?? "allowlist";
+    if (policy2 === "disabled") {
+      return false;
+    }
+    if (policy2 === "open") {
+      return true;
+    }
+    if (groupConfig?.allowFrom?.length) {
+      return groupConfig.allowFrom.some((allowed) => String(allowed) === identifier);
+    }
+    if (accountConfig.groupAllowFrom?.length) {
+      return accountConfig.groupAllowFrom.some((allowed) => String(allowed) === identifier);
+    }
+    return policy2 !== "allowlist";
+  }
+  const policy = accountConfig.dmPolicy ?? "pairing";
+  if (policy === "disabled") {
+    return false;
+  }
+  if (policy === "open") {
+    return true;
+  }
+  if (policy === "pairing") {
+    return true;
+  }
+  if (accountConfig.allowFrom?.length) {
+    return accountConfig.allowFrom.some((allowed) => String(allowed) === identifier);
+  }
+  return false;
+}
+function isWhatsAppMentionRequired(params) {
+  const { groupConfig } = params;
+  return groupConfig?.requireMention ?? false;
+}
+async function checkWhatsAppUserAccess(params) {
+  const { runtime, identifier, accountConfig, isGroup, groupConfig, metadata } = params;
+  if (isGroup) {
+    const policy2 = accountConfig.groupPolicy ?? "allowlist";
+    if (policy2 === "disabled") {
+      return { allowed: false };
+    }
+    if (policy2 === "open") {
+      return { allowed: true };
+    }
+    if (groupConfig?.allowFrom?.length) {
+      const allowed = groupConfig.allowFrom.some((a) => String(a) === identifier);
+      return { allowed };
+    }
+    if (accountConfig.groupAllowFrom?.length) {
+      const allowed = accountConfig.groupAllowFrom.some((a) => String(a) === identifier);
+      return { allowed };
+    }
+    return { allowed: policy2 !== "allowlist" };
+  }
+  const policy = accountConfig.dmPolicy ?? "pairing";
+  if (policy === "disabled") {
+    return { allowed: false };
+  }
+  if (policy === "open") {
+    return { allowed: true };
+  }
+  if (policy === "pairing") {
+    const result = await checkPairingAllowed(runtime, {
+      channel: "whatsapp",
+      senderId: identifier,
+      metadata
+    });
+    return {
+      allowed: result.allowed,
+      pairingCode: result.pairingCode,
+      newPairingRequest: result.newRequest,
+      replyMessage: result.replyMessage
+    };
+  }
+  if (accountConfig.allowFrom?.length) {
+    const allowed = accountConfig.allowFrom.some((a) => String(a) === identifier);
+    if (allowed) {
+      return { allowed: true };
+    }
+  }
+  const inDynamicAllowlist = await isInAllowlist(runtime, "whatsapp", identifier);
+  return { allowed: inDynamicAllowlist };
+}
+// src/normalize.ts
+var WHATSAPP_TEXT_CHUNK_LIMIT = 4096;
+var WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+var WHATSAPP_LID_RE = /^(\d+)@lid$/i;
+function stripWhatsAppTargetPrefixes(value) {
+  let candidate = value.trim();
+  for (;; ) {
+    const before = candidate;
+    candidate = candidate.replace(/^whatsapp:/i, "").trim();
+    if (candidate === before) {
+      return candidate;
+    }
+  }
+}
+function normalizeE164(input) {
+  const stripped = input.replace(/[\s\-().]+/g, "");
+  const digitsOnly = stripped.replace(/[^\d+]/g, "");
+  if (!digitsOnly) {
+    return "";
+  }
+  if (digitsOnly.startsWith("+")) {
+    return digitsOnly;
+  }
+  if (digitsOnly.startsWith("00")) {
+    return `+${digitsOnly.slice(2)}`;
+  }
+  if (digitsOnly.length >= 10) {
+    return `+${digitsOnly}`;
+  }
+  return digitsOnly;
+}
+function isWhatsAppGroupJid(value) {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  const lower = candidate.toLowerCase();
+  if (!lower.endsWith("@g.us")) {
+    return false;
+  }
+  const localPart = candidate.slice(0, candidate.length - "@g.us".length);
+  if (!localPart || localPart.includes("@")) {
+    return false;
+  }
+  return /^[0-9]+(-[0-9]+)*$/.test(localPart);
+}
+function isWhatsAppUserTarget(value) {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  return WHATSAPP_USER_JID_RE.test(candidate) || WHATSAPP_LID_RE.test(candidate);
+}
+function extractUserJidPhone(jid) {
+  const userMatch = jid.match(WHATSAPP_USER_JID_RE);
+  if (userMatch) {
+    return userMatch[1];
+  }
+  const lidMatch = jid.match(WHATSAPP_LID_RE);
+  if (lidMatch) {
+    return lidMatch[1];
+  }
+  return null;
+}
+function normalizeWhatsAppTarget(value) {
+  const candidate = stripWhatsAppTargetPrefixes(value);
+  if (!candidate) {
+    return null;
+  }
+  if (isWhatsAppGroupJid(candidate)) {
+    const localPart = candidate.slice(0, candidate.length - "@g.us".length);
+    return `${localPart}@g.us`;
+  }
+  if (isWhatsAppUserTarget(candidate)) {
+    const phone = extractUserJidPhone(candidate);
+    if (!phone) {
+      return null;
+    }
+    const normalized2 = normalizeE164(phone);
+    return normalized2.length > 1 ? normalized2 : null;
+  }
+  if (candidate.includes("@")) {
+    return null;
+  }
+  const normalized = normalizeE164(candidate);
+  return normalized.length > 1 ? normalized : null;
+}
+function formatWhatsAppId(id) {
+  if (isWhatsAppGroupJid(id)) {
+    return `group:${id}`;
+  }
+  const normalized = normalizeWhatsAppTarget(id);
+  return normalized || id;
+}
+function isWhatsAppGroup(id) {
+  return isWhatsAppGroupJid(id);
+}
+function getWhatsAppChatType(id) {
+  return isWhatsAppGroupJid(id) ? "group" : "user";
+}
+function buildWhatsAppUserJid(phoneNumber) {
+  const normalized = normalizeE164(phoneNumber);
+  const digits = normalized.replace(/^\+/, "");
+  return `${digits}@s.whatsapp.net`;
+}
+function splitAtBreakPoint(text, limit) {
+  if (text.length <= limit) {
+    return { chunk: text, remainder: "" };
+  }
+  const searchArea = text.slice(0, limit);
+  const doubleNewline = searchArea.lastIndexOf(`
+
+`);
+  if (doubleNewline > limit * 0.5) {
+    return {
+      chunk: text.slice(0, doubleNewline).trimEnd(),
+      remainder: text.slice(doubleNewline + 2).trimStart()
+    };
+  }
+  const singleNewline = searchArea.lastIndexOf(`
+`);
+  if (singleNewline > limit * 0.5) {
+    return {
+      chunk: text.slice(0, singleNewline).trimEnd(),
+      remainder: text.slice(singleNewline + 1).trimStart()
+    };
+  }
+  const sentenceEnd = Math.max(searchArea.lastIndexOf(". "), searchArea.lastIndexOf("! "), searchArea.lastIndexOf("? "));
+  if (sentenceEnd > limit * 0.5) {
+    return {
+      chunk: text.slice(0, sentenceEnd + 1).trimEnd(),
+      remainder: text.slice(sentenceEnd + 2).trimStart()
+    };
+  }
+  const space = searchArea.lastIndexOf(" ");
+  if (space > limit * 0.5) {
+    return {
+      chunk: text.slice(0, space).trimEnd(),
+      remainder: text.slice(space + 1).trimStart()
+    };
+  }
+  return {
+    chunk: text.slice(0, limit),
+    remainder: text.slice(limit)
+  };
+}
+function chunkWhatsAppText(text, opts = {}) {
+  const limit = opts.limit ?? WHATSAPP_TEXT_CHUNK_LIMIT;
+  if (!text?.trim()) {
+    return [];
+  }
+  const normalizedText = text.trim();
+  if (normalizedText.length <= limit) {
+    return [normalizedText];
+  }
+  const chunks = [];
+  let remaining = normalizedText;
+  while (remaining.length > 0) {
+    const { chunk, remainder } = splitAtBreakPoint(remaining, limit);
+    if (chunk) {
+      chunks.push(chunk);
+    }
+    remaining = remainder;
+  }
+  return chunks.filter((c) => c.length > 0);
+}
+function truncateText(text, maxLength) {
+  if (text.length <= maxLength) {
+    return text;
+  }
+  if (maxLength <= 3) {
+    return "...".slice(0, maxLength);
+  }
+  return `${text.slice(0, maxLength - 3)}...`;
+}
+function resolveWhatsAppSystemLocation(params) {
+  const { chatType, chatId, chatName } = params;
+  const name = chatName || chatId.slice(0, 8);
+  return `WhatsApp ${chatType}:${name}`;
+}
+function isValidWhatsAppNumber(value) {
+  const normalized = normalizeWhatsAppTarget(value);
+  if (!normalized) {
+    return false;
+  }
+  if (!normalized.startsWith("+")) {
+    return false;
+  }
+  const digits = normalized.replace(/^\+/, "");
+  return /^\d{10,15}$/.test(digits);
+}
+function formatWhatsAppPhoneNumber(phoneNumber) {
+  const normalized = normalizeE164(phoneNumber);
+  if (!normalized) {
+    return phoneNumber;
+  }
+  const digits = normalized.replace(/^\+/, "");
+  if (digits.length <= 10) {
+    return normalized;
+  }
+  const countryCode = digits.slice(0, digits.length - 10);
+  const rest = digits.slice(-10);
+  return `+${countryCode} ${rest.slice(0, 3)} ${rest.slice(3, 6)} ${rest.slice(6)}`;
+}
+// src/types.ts
+var WhatsAppEventType;
+((WhatsAppEventType2) => {
+  WhatsAppEventType2["MESSAGE_RECEIVED"] = "WHATSAPP_MESSAGE_RECEIVED";
+  WhatsAppEventType2["MESSAGE_SENT"] = "WHATSAPP_MESSAGE_SENT";
+  WhatsAppEventType2["MESSAGE_DELIVERED"] = "WHATSAPP_MESSAGE_DELIVERED";
+  WhatsAppEventType2["MESSAGE_READ"] = "WHATSAPP_MESSAGE_READ";
+  WhatsAppEventType2["MESSAGE_FAILED"] = "WHATSAPP_MESSAGE_FAILED";
+  WhatsAppEventType2["REACTION_RECEIVED"] = "WHATSAPP_REACTION_RECEIVED";
+  WhatsAppEventType2["REACTION_SENT"] = "WHATSAPP_REACTION_SENT";
+  WhatsAppEventType2["INTERACTIVE_REPLY"] = "WHATSAPP_INTERACTIVE_REPLY";
+  WhatsAppEventType2["WEBHOOK_VERIFIED"] = "WHATSAPP_WEBHOOK_VERIFIED";
+})(WhatsAppEventType ||= {});
+var WHATSAPP_REACTIONS = {
+  THUMBS_UP: "\uD83D\uDC4D",
+  THUMBS_DOWN: "\uD83D\uDC4E",
+  HEART: "❤️",
+  LAUGHING: "\uD83D\uDE02",
+  SURPRISED: "\uD83D\uDE2E",
+  SAD: "\uD83D\uDE22",
+  PRAYING: "\uD83D\uDE4F",
+  CLAPPING: "\uD83D\uDC4F",
+  FIRE: "\uD83D\uDD25",
+  CELEBRATION: "\uD83C\uDF89"
+};
+
+// src/index.ts
+class WhatsAppPlugin extends EventEmitter4 {
+  client;
+  messageHandler;
+  webhookHandler;
+  name;
+  description;
+  actions = [sendMessageAction, sendReactionAction];
+  constructor(config) {
+    super();
+    this.name = "WhatsApp Plugin";
+    this.description = "WhatsApp integration supporting Cloud API and Baileys (QR auth)";
+    this.client = ClientFactory.create(config);
+    this.messageHandler = new MessageHandler(this.client);
+    this.webhookHandler = new WebhookHandler;
+    this.setupEventForwarding();
+  }
+  setupEventForwarding() {
+    this.client.on("message", (payload) => this.emit("message", payload));
+    this.client.on("qr", (payload) => this.emit("qr", payload));
+    this.client.on("ready", () => this.emit("ready"));
+    this.client.on("connection", (status) => this.emit("connection", status));
+    this.client.on("error", (error) => this.emit("error", error));
+  }
+  async start() {
+    await this.client.start();
+  }
+  async stop() {
+    await this.client.stop();
+  }
+  getConnectionStatus() {
+    return this.client.getConnectionStatus();
+  }
+  async sendMessage(message2) {
+    return this.messageHandler.send(message2);
+  }
+  async handleWebhook(event) {
+    return this.webhookHandler.handle(event);
+  }
+  async verifyWebhook(token) {
+    if (!this.client.verifyWebhook) {
+      throw new Error("verifyWebhook is only supported by Cloud API authentication");
+    }
+    return this.client.verifyWebhook(token);
+  }
+}
+var whatsappPlugin = {
+  name: "whatsapp",
+  description: "WhatsApp integration for ElizaOS (Cloud API + Baileys)",
+  actions: [sendMessageAction, sendReactionAction]
+};
+var src_default = whatsappPlugin;
+export {
+  truncateText,
+  resolveWhatsAppToken,
+  resolveWhatsAppSystemLocation,
+  resolveWhatsAppGroupConfig,
+  resolveWhatsAppAccount,
+  resolveDefaultWhatsAppAccountId,
+  normalizeWhatsAppTarget,
+  normalizeE164,
+  normalizeAccountId,
+  listWhatsAppAccountIds,
+  listEnabledWhatsAppAccounts,
+  isWhatsAppUserTarget,
+  isWhatsAppUserAllowed,
+  isWhatsAppMentionRequired,
+  isWhatsAppGroupJid,
+  isWhatsAppGroup,
+  isValidWhatsAppNumber,
+  isMultiAccountEnabled,
+  getWhatsAppChatType,
+  formatWhatsAppPhoneNumber,
+  formatWhatsAppId,
+  src_default as default,
+  chunkWhatsAppText,
+  checkWhatsAppUserAccess,
+  buildWhatsAppUserJid,
+  WhatsAppPlugin,
+  WhatsAppEventType,
+  WHATSAPP_TEXT_CHUNK_LIMIT,
+  WHATSAPP_REACTIONS,
+  DEFAULT_ACCOUNT_ID,
+  ClientFactory
+};
+
+//# debugId=3ABF74EE0B1ACBEC64756E2164756E21
+//# sourceMappingURL=index.js.map