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

package/dist/index.js

@@ -0,0 +1,2298 @@
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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",
+  descriptionCompressed: "Send WhatsApp text message.",
+  suppressPostActionContinuation: true,
+  validate: async (_runtime, message, _state, _options) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasIntent = ["whatsapp", "send", "message"].some((keyword) => text.includes(keyword)) && /\b(?:whatsapp|send|message)\b/i.test(text);
+    return hasIntent && message.content?.source === "whatsapp";
+  },
+  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?.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;
+      return {
+        success: true,
+        data: {
+          action: WHATSAPP_SEND_MESSAGE_ACTION,
+          to: params.to,
+          messageId,
+          suppressVisibleCallback: true,
+          suppressActionResultClipboard: true
+        }
+      };
+    } 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",
+  descriptionCompressed: "React to WhatsApp message with emoji.",
+  suppressPostActionContinuation: true,
+  validate: async (_runtime, message, _state, _options) => {
+    const text = message.content?.text?.toLowerCase() ?? "";
+    const hasIntent = ["whatsapp", "send", "reaction"].some((keyword) => text.includes(keyword)) && /\b(?:whatsapp|send|reaction)\b/i.test(text);
+    return hasIntent && message.content?.source === "whatsapp";
+  },
+  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?.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}`);
+      }
+      return {
+        success: true,
+        data: {
+          action: WHATSAPP_SEND_REACTION_ACTION,
+          messageId: params.messageId,
+          emoji: params.emoji,
+          suppressVisibleCallback: true,
+          suppressActionResultClipboard: true
+        }
+      };
+    } 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/runtime-service.ts
+import {
+  ChannelType,
+  createUniqueUuid,
+  lifeOpsPassiveConnectorsEnabled,
+  Service
+} from "@elizaos/core";
+
+// 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/client.ts
+import { EventEmitter } from "node:events";
+import axios from "axios";
+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/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 { EventEmitter as EventEmitter2 } from "node:events";
+import makeWASocket, { DisconnectReason } from "@whiskeysockets/baileys";
+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 * 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 {
+  toNormalized(msg) {
+    const chatId = msg.key?.remoteJid ?? "";
+    const senderId = msg.key?.participant ?? chatId;
+    return {
+      id: msg.key?.id ?? "",
+      from: chatId,
+      timestamp: Number(msg.messageTimestamp ?? 0),
+      type: this.detectType(msg),
+      content: this.extractContent(msg),
+      chatId,
+      senderId,
+      replyToId: this.extractReplyToId(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 ?? msg.message?.imageMessage?.caption ?? msg.message?.videoMessage?.caption ?? msg.message?.documentMessage?.caption ?? "";
+  }
+  extractReplyToId(msg) {
+    const contextInfo = msg.message?.extendedTextMessage?.contextInfo ?? msg.message?.imageMessage?.contextInfo ?? msg.message?.videoMessage?.contextInfo ?? msg.message?.documentMessage?.contextInfo;
+    return typeof contextInfo?.stanzaId === "string" ? contextInfo.stanzaId : undefined;
+  }
+  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.toNormalized(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();
+  }
+  getPhoneNumber() {
+    return this.connection.getSocket()?.user?.id?.split(":")[0] ?? null;
+  }
+}
+
+// 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/runtime-service.ts
+function readStringSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
+  }
+  const envValue = process.env[key];
+  if (typeof envValue === "string" && envValue.trim().length > 0) {
+    return envValue.trim();
+  }
+  return;
+}
+function readCsvSetting(runtime, key) {
+  const value = readStringSetting(runtime, key);
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+}
+function resolveRuntimeConfig(runtime) {
+  const dmPolicy = readStringSetting(runtime, "WHATSAPP_DM_POLICY");
+  const groupPolicy = readStringSetting(runtime, "WHATSAPP_GROUP_POLICY");
+  const allowFrom = readCsvSetting(runtime, "WHATSAPP_ALLOW_FROM");
+  const groupAllowFrom = readCsvSetting(runtime, "WHATSAPP_GROUP_ALLOW_FROM");
+  const authDir = readStringSetting(runtime, "WHATSAPP_AUTH_DIR") ?? readStringSetting(runtime, "WHATSAPP_SESSION_PATH");
+  if (authDir) {
+    return {
+      transport: "baileys",
+      authDir,
+      dmPolicy,
+      groupPolicy,
+      allowFrom,
+      groupAllowFrom
+    };
+  }
+  const accessToken = readStringSetting(runtime, "WHATSAPP_ACCESS_TOKEN");
+  const phoneNumberId = readStringSetting(runtime, "WHATSAPP_PHONE_NUMBER_ID");
+  if (accessToken && phoneNumberId) {
+    return {
+      transport: "cloudapi",
+      accessToken,
+      phoneNumberId,
+      webhookVerifyToken: readStringSetting(runtime, "WHATSAPP_WEBHOOK_VERIFY_TOKEN"),
+      apiVersion: readStringSetting(runtime, "WHATSAPP_API_VERSION"),
+      dmPolicy,
+      groupPolicy,
+      allowFrom,
+      groupAllowFrom
+    };
+  }
+  return null;
+}
+function toTimestampMs(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return Date.now();
+  }
+  return parsed >= 1000000000000 ? parsed : parsed * 1000;
+}
+function toMemoryId(runtime, chatId, messageId) {
+  return createUniqueUuid(runtime, `whatsapp:${chatId}:${messageId}`);
+}
+function normalizeBaileysSendTarget(target) {
+  if (isWhatsAppGroupJid(target) || isWhatsAppUserTarget(target)) {
+    return target;
+  }
+  const normalized = normalizeWhatsAppTarget(target);
+  return normalized ? buildWhatsAppUserJid(normalized) : target;
+}
+function extractWebhookText(message) {
+  if (typeof message.text?.body === "string" && message.text.body.trim()) {
+    return message.text.body.trim();
+  }
+  if (typeof message.interactive?.button_reply?.title === "string" && message.interactive.button_reply.title.trim()) {
+    return message.interactive.button_reply.title.trim();
+  }
+  if (typeof message.interactive?.list_reply?.title === "string" && message.interactive.list_reply.title.trim()) {
+    return message.interactive.list_reply.title.trim();
+  }
+  if (typeof message.interactive?.nfm_reply?.body === "string" && message.interactive.nfm_reply.body.trim()) {
+    return message.interactive.nfm_reply.body.trim();
+  }
+  if (typeof message.image?.caption === "string" && message.image.caption.trim()) {
+    return message.image.caption.trim();
+  }
+  if (typeof message.video?.caption === "string" && message.video.caption.trim()) {
+    return message.video.caption.trim();
+  }
+  if (typeof message.document?.caption === "string" && message.document.caption.trim()) {
+    return message.document.caption.trim();
+  }
+  if (message.reaction?.emoji) {
+    return `Reaction: ${message.reaction.emoji}`;
+  }
+  if (message.location) {
+    const { latitude, longitude } = message.location;
+    return `Location: ${latitude}, ${longitude}`;
+  }
+  return "";
+}
+
+class WhatsAppConnectorService extends Service {
+  static serviceType = "whatsapp";
+  capabilityDescription = "The agent is able to send and receive messages on whatsapp";
+  connected = false;
+  phoneNumber = null;
+  client = null;
+  config = null;
+  constructor(runtime) {
+    super(runtime);
+    if (runtime) {
+      this.runtime = runtime;
+    }
+  }
+  static async start(runtime) {
+    const service = new WhatsAppConnectorService(runtime);
+    await service.initialize();
+    return service;
+  }
+  async initialize() {
+    this.config = resolveRuntimeConfig(this.runtime);
+    if (!this.config) {
+      this.runtime.logger.warn({ src: "plugin:whatsapp", agentId: this.runtime.agentId }, "WhatsApp connector is not configured");
+      return;
+    }
+    this.client = this.config.transport === "baileys" ? new BaileysClient({
+      authMethod: "baileys",
+      authDir: this.config.authDir,
+      printQRInTerminal: false
+    }) : new WhatsAppClient({
+      accessToken: this.config.accessToken,
+      phoneNumberId: this.config.phoneNumberId,
+      webhookVerifyToken: this.config.webhookVerifyToken,
+      apiVersion: this.config.apiVersion
+    });
+    this.bindClientEvents(this.client);
+    await this.client.start();
+    if (this.config.transport === "cloudapi") {
+      this.connected = true;
+    }
+  }
+  async stop() {
+    if (this.client) {
+      await this.client.stop();
+    }
+    this.connected = false;
+    this.phoneNumber = null;
+  }
+  async handleWebhook(event) {
+    for (const entry of event.entry ?? []) {
+      for (const change of entry.changes ?? []) {
+        const value = change.value;
+        if (typeof value?.metadata?.display_phone_number === "string") {
+          this.phoneNumber = value.metadata.display_phone_number;
+        }
+        for (const message of value?.messages ?? []) {
+          await this.handleIncomingWebhookMessage(message);
+        }
+      }
+    }
+  }
+  verifyWebhook(mode, token, challenge) {
+    const expectedToken = this.config?.transport === "cloudapi" ? this.config.webhookVerifyToken : readStringSetting(this.runtime, "WHATSAPP_WEBHOOK_VERIFY_TOKEN");
+    if (mode === "subscribe" && expectedToken && token === expectedToken && challenge) {
+      return challenge;
+    }
+    return null;
+  }
+  bindClientEvents(client) {
+    client.on("connection", (status) => {
+      this.connected = status === "open";
+      if (status === "open" && client instanceof BaileysClient) {
+        const nextPhone = client.getPhoneNumber();
+        this.phoneNumber = (nextPhone && normalizeWhatsAppTarget(nextPhone)) ?? nextPhone;
+      }
+      if (status === "close") {
+        this.phoneNumber = null;
+      }
+    });
+    client.on("ready", () => {
+      this.connected = true;
+      if (client instanceof BaileysClient) {
+        const nextPhone = client.getPhoneNumber();
+        this.phoneNumber = (nextPhone && normalizeWhatsAppTarget(nextPhone)) ?? nextPhone;
+      }
+    });
+    client.on("message", (message) => {
+      this.handleNormalizedMessage(message).catch((error) => {
+        this.runtime.logger.error({
+          src: "plugin:whatsapp",
+          agentId: this.runtime.agentId,
+          error: error instanceof Error ? error.message : String(error)
+        }, "Failed to process inbound WhatsApp message");
+      });
+    });
+    client.on("error", (error) => {
+      this.runtime.logger.error({
+        src: "plugin:whatsapp",
+        agentId: this.runtime.agentId,
+        error: error instanceof Error ? error.message : String(error)
+      }, "WhatsApp client error");
+    });
+  }
+  async handleNormalizedMessage(message) {
+    const chatId = message.chatId ?? message.from;
+    const senderId = message.senderId ?? message.from;
+    const text = typeof message.content === "string" ? message.content.trim() : "";
+    if (!chatId || !senderId || !text) {
+      return;
+    }
+    await this.processIncomingMessage({
+      chatId,
+      senderId,
+      text,
+      externalMessageId: message.id,
+      replyToExternalMessageId: message.replyToId,
+      createdAt: toTimestampMs(message.timestamp)
+    });
+  }
+  async handleIncomingWebhookMessage(message) {
+    const text = extractWebhookText(message);
+    if (!text) {
+      return;
+    }
+    const normalizedSender = normalizeWhatsAppTarget(message.from) ?? message.from;
+    await this.processIncomingMessage({
+      chatId: normalizedSender,
+      senderId: normalizedSender,
+      text,
+      externalMessageId: message.id,
+      replyToExternalMessageId: message.context?.id,
+      createdAt: toTimestampMs(message.timestamp)
+    });
+  }
+  async processIncomingMessage(params) {
+    if (!this.runtime.messageService) {
+      throw new Error("WhatsApp connector requires runtime.messageService");
+    }
+    const isGroup = isWhatsAppGroupJid(params.chatId);
+    const normalizedSender = normalizeWhatsAppTarget(params.senderId) ?? params.senderId;
+    const accountConfig = {
+      dmPolicy: this.config?.dmPolicy,
+      groupPolicy: this.config?.groupPolicy,
+      allowFrom: this.config?.allowFrom,
+      groupAllowFrom: this.config?.groupAllowFrom
+    };
+    const access = await checkWhatsAppUserAccess({
+      runtime: this.runtime,
+      identifier: normalizedSender,
+      accountConfig,
+      isGroup,
+      ...isGroup ? { groupId: params.chatId } : {},
+      metadata: { senderId: normalizedSender }
+    });
+    if (!access.allowed) {
+      if (access.replyMessage) {
+        await this.sendTextMessage(params.chatId, access.replyMessage);
+      }
+      return;
+    }
+    const channelType = isGroup ? ChannelType.GROUP : ChannelType.DM;
+    const roomId = createUniqueUuid(this.runtime, `whatsapp-room:${params.chatId}`);
+    const worldId = createUniqueUuid(this.runtime, `whatsapp-world:${params.chatId}`);
+    const entityId = createUniqueUuid(this.runtime, `whatsapp-entity:${normalizedSender}`);
+    const inboundMemoryId = toMemoryId(this.runtime, params.chatId, params.externalMessageId);
+    await this.runtime.ensureConnection({
+      entityId,
+      roomId,
+      userId: normalizedSender,
+      userName: normalizedSender,
+      name: normalizedSender,
+      source: "whatsapp",
+      channelId: params.chatId,
+      type: channelType,
+      worldId,
+      worldName: resolveWhatsAppSystemLocation({
+        chatType: isGroup ? "group" : "user",
+        chatId: params.chatId
+      })
+    });
+    const inboundMemory = {
+      id: inboundMemoryId,
+      entityId,
+      agentId: this.runtime.agentId,
+      roomId,
+      content: {
+        text: params.text,
+        source: "whatsapp",
+        channelType,
+        from: normalizedSender,
+        messageId: params.externalMessageId,
+        ...params.replyToExternalMessageId ? {
+          inReplyTo: toMemoryId(this.runtime, params.chatId, params.replyToExternalMessageId)
+        } : {}
+      },
+      metadata: {
+        type: "message",
+        source: "whatsapp",
+        provider: "whatsapp",
+        timestamp: params.createdAt,
+        entityName: normalizedSender,
+        entityUserName: normalizedSender,
+        fromBot: false,
+        fromId: normalizedSender,
+        sourceId: entityId,
+        chatType: channelType,
+        messageIdFull: params.externalMessageId,
+        sender: {
+          id: normalizedSender,
+          name: normalizedSender,
+          username: normalizedSender
+        },
+        whatsapp: {
+          id: normalizedSender,
+          userId: normalizedSender,
+          username: normalizedSender,
+          userName: normalizedSender,
+          name: normalizedSender,
+          chatId: params.chatId,
+          messageId: params.externalMessageId
+        },
+        rawChatId: params.chatId,
+        rawSenderId: params.senderId
+      },
+      createdAt: params.createdAt
+    };
+    const callback = async (content) => {
+      const text = typeof content.text === "string" ? content.text.trim() : "";
+      if (!text) {
+        return [];
+      }
+      const chunks = chunkWhatsAppText(text);
+      const responseMemories = [];
+      for (const [index, chunk] of chunks.entries()) {
+        const response = await this.sendTextMessage(params.chatId, chunk, params.externalMessageId);
+        const externalResponseId = response.messages?.[0]?.id ?? `${params.externalMessageId}:response:${index}:${Date.now()}`;
+        responseMemories.push({
+          id: toMemoryId(this.runtime, params.chatId, externalResponseId),
+          entityId: this.runtime.agentId,
+          agentId: this.runtime.agentId,
+          roomId,
+          content: {
+            ...content,
+            text: chunk,
+            source: "whatsapp",
+            channelType,
+            inReplyTo: inboundMemoryId
+          },
+          metadata: {
+            type: "message",
+            source: "whatsapp",
+            provider: "whatsapp",
+            timestamp: Date.now(),
+            fromBot: true,
+            fromId: this.runtime.agentId,
+            sourceId: this.runtime.agentId,
+            chatType: channelType,
+            messageIdFull: externalResponseId,
+            whatsapp: {
+              chatId: params.chatId,
+              messageId: externalResponseId
+            },
+            rawChatId: params.chatId,
+            externalMessageId: externalResponseId
+          },
+          createdAt: Date.now()
+        });
+      }
+      return responseMemories;
+    };
+    const autoReplyRaw = this.runtime.getSetting("WHATSAPP_AUTO_REPLY");
+    const autoReply = !lifeOpsPassiveConnectorsEnabled(this.runtime) && (autoReplyRaw === true || autoReplyRaw === "true");
+    if (!autoReply) {
+      await this.runtime.createMemory(inboundMemory, "messages");
+      return;
+    }
+    await this.runtime.messageService.handleMessage(this.runtime, inboundMemory, callback);
+  }
+  async sendTextMessage(chatId, text, replyToMessageId) {
+    if (!this.client || !this.config) {
+      throw new Error("WhatsApp client is not initialized");
+    }
+    const response = await this.client.sendMessage({
+      type: "text",
+      to: this.config.transport === "baileys" ? normalizeBaileysSendTarget(chatId) : normalizeWhatsAppTarget(chatId) ?? chatId,
+      content: text,
+      replyToMessageId
+    });
+    return "data" in response ? response.data : response;
+  }
+  async sendMessage(message) {
+    return this.sendTextMessage(message.to, message.content, message.replyToMessageId);
+  }
+}
+
+// src/setup-routes.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+
+// src/pairing-service.ts
+import fs from "node:fs";
+import path from "node:path";
+var LOG_PREFIX = "[whatsapp-pairing]";
+function sanitizeAccountId(raw) {
+  const cleaned = raw.replace(/[^a-zA-Z0-9_-]/g, "");
+  if (!cleaned || cleaned !== raw) {
+    throw new Error(`Invalid accountId: must only contain alphanumeric characters, dashes, and underscores`);
+  }
+  return cleaned;
+}
+
+class WhatsAppPairingSession {
+  socket = null;
+  status = "idle";
+  options;
+  qrAttempts = 0;
+  MAX_QR_ATTEMPTS = 5;
+  restartTimer = null;
+  constructor(options) {
+    this.options = options;
+  }
+  async start() {
+    this.setStatus("initializing");
+    const baileys = await import("@whiskeysockets/baileys");
+    const makeWASocket2 = baileys.default;
+    const { useMultiFileAuthState: useMultiFileAuthState2, fetchLatestBaileysVersion, DisconnectReason: DisconnectReason2 } = baileys;
+    const QRCode2 = (await import("qrcode")).default;
+    const { Boom } = await import("@hapi/boom");
+    fs.mkdirSync(this.options.authDir, { recursive: true });
+    const { state, saveCreds } = await useMultiFileAuthState2(this.options.authDir);
+    const { version } = await fetchLatestBaileysVersion();
+    const pino2 = (await import("pino")).default;
+    const baileysLogger = pino2({ level: "silent" });
+    this.socket = makeWASocket2({
+      version,
+      auth: state,
+      logger: baileysLogger,
+      printQRInTerminal: false,
+      browser: ["Eliza AI", "Desktop", "1.0.0"]
+    });
+    this.socket.ev.on("creds.update", saveCreds);
+    this.socket.ev.on("connection.update", async (update) => {
+      const { connection, lastDisconnect, qr } = update;
+      if (qr) {
+        this.qrAttempts++;
+        console.info(`${LOG_PREFIX} QR code received (attempt ${this.qrAttempts}/${this.MAX_QR_ATTEMPTS})`);
+        if (this.qrAttempts > this.MAX_QR_ATTEMPTS) {
+          this.setStatus("timeout");
+          this.stop();
+          return;
+        }
+        try {
+          const qrDataUrl = await QRCode2.toDataURL(qr, {
+            width: 256,
+            margin: 2,
+            color: { dark: "#000000", light: "#ffffff" }
+          });
+          this.setStatus("waiting_for_qr");
+          this.options.onEvent({
+            type: "whatsapp-qr",
+            accountId: this.options.accountId,
+            qrDataUrl,
+            expiresInMs: 20000
+          });
+        } catch {}
+      }
+      if (connection === "close") {
+        const statusCode = lastDisconnect?.error?.output?.statusCode;
+        console.info(`${LOG_PREFIX} Connection closed, statusCode=${statusCode}, status=${this.status}`);
+        if (statusCode === DisconnectReason2.loggedOut) {
+          this.setStatus("disconnected");
+        } else if (statusCode === DisconnectReason2.restartRequired || statusCode === DisconnectReason2.timedOut || statusCode === DisconnectReason2.connectionClosed || statusCode === DisconnectReason2.connectionReplaced) {
+          console.info(`${LOG_PREFIX} Restarting pairing after transient close...`);
+          this.socket = null;
+          this.qrAttempts = 0;
+          this.restartTimer = setTimeout(() => {
+            this.restartTimer = null;
+            this.start().catch((err) => {
+              console.error(`${LOG_PREFIX} Restart failed:`, err);
+              this.setStatus("error");
+              this.options.onEvent({
+                type: "whatsapp-status",
+                accountId: this.options.accountId,
+                status: "error",
+                error: String(err)
+              });
+            });
+          }, 3000);
+        }
+      } else if (connection === "open") {
+        const phoneNumber = this.socket?.user?.id?.split(":")[0] ?? "";
+        this.setStatus("connected");
+        this.options.onEvent({
+          type: "whatsapp-status",
+          accountId: this.options.accountId,
+          status: "connected",
+          phoneNumber
+        });
+      }
+    });
+  }
+  stop() {
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = null;
+    }
+    try {
+      this.socket?.end(undefined);
+    } catch {}
+    this.socket = null;
+  }
+  getStatus() {
+    return this.status;
+  }
+  setStatus(status) {
+    this.status = status;
+    this.options.onEvent({
+      type: "whatsapp-status",
+      accountId: this.options.accountId,
+      status
+    });
+  }
+}
+function whatsappAuthExists(workspaceDir, accountId = "default") {
+  const credsPath = path.join(workspaceDir, "whatsapp-auth", accountId, "creds.json");
+  return fs.existsSync(credsPath);
+}
+async function whatsappLogout(workspaceDir, accountId = "default") {
+  const authDir = path.join(workspaceDir, "whatsapp-auth", accountId);
+  const credsPath = path.join(authDir, "creds.json");
+  if (fs.existsSync(credsPath)) {
+    try {
+      const baileys = await import("@whiskeysockets/baileys");
+      const makeWASocket2 = baileys.default;
+      const { useMultiFileAuthState: useMultiFileAuthState2, fetchLatestBaileysVersion } = baileys;
+      const pino2 = (await import("pino")).default;
+      const logger = pino2({ level: "silent" });
+      const { state } = await useMultiFileAuthState2(authDir);
+      const { version } = await fetchLatestBaileysVersion();
+      const sock = makeWASocket2({
+        version,
+        auth: state,
+        logger,
+        printQRInTerminal: false
+      });
+      await new Promise((resolve) => {
+        let settled = false;
+        const finish = () => {
+          if (settled)
+            return;
+          settled = true;
+          clearTimeout(timeout);
+          try {
+            sock.ev.removeAllListeners("connection.update");
+          } catch {}
+          try {
+            sock.end(undefined);
+          } catch {}
+          resolve();
+        };
+        const timeout = setTimeout(finish, 1e4);
+        sock.ev.on("connection.update", async (update) => {
+          if (update.connection === "open") {
+            try {
+              await sock.logout();
+            } catch {}
+            finish();
+          } else if (update.connection === "close") {
+            finish();
+          }
+        });
+      });
+    } catch {}
+  }
+  fs.rmSync(authDir, { recursive: true, force: true });
+}
+
+// src/setup-routes.ts
+var whatsappPairingSessions = new Map;
+var MAX_PAIRING_SESSIONS = 10;
+function isConnectorSetupService(service) {
+  return typeof service === "object" && service !== null && typeof service.getConfig === "function" && typeof service.persistConfig === "function" && typeof service.updateConfig === "function" && typeof service.registerEscalationChannel === "function" && typeof service.setOwnerContact === "function" && typeof service.getWorkspaceDir === "function" && typeof service.broadcastWs === "function";
+}
+function getSetupService(runtime) {
+  const service = runtime.getService("connector-setup");
+  return isConnectorSetupService(service) ? service : null;
+}
+function cleanupStaleSessions() {
+  for (const [id, session] of whatsappPairingSessions) {
+    const status = session.getStatus();
+    if (status === "disconnected" || status === "timeout" || status === "error") {
+      session.stop();
+      whatsappPairingSessions.delete(id);
+    }
+  }
+}
+async function handleWebhookVerify(req, res, runtime) {
+  const url = new URL(req.url ?? "/", `http://${req.headers?.host ?? "localhost"}`);
+  const mode = url.searchParams.get("hub.mode") ?? "";
+  const token = url.searchParams.get("hub.verify_token") ?? "";
+  const challenge = url.searchParams.get("hub.challenge") ?? "";
+  const service = runtime.getService("whatsapp");
+  if (!service || typeof service.verifyWebhook !== "function") {
+    res.status(503).json({ error: "WhatsApp service unavailable" });
+    return;
+  }
+  const verifiedChallenge = service.verifyWebhook(mode, token, challenge);
+  if (!verifiedChallenge) {
+    res.status(403).json({ error: "Webhook verification failed" });
+    return;
+  }
+  res.status(200).json(verifiedChallenge);
+}
+async function handleWebhookEvent(req, res, runtime) {
+  const service = runtime.getService("whatsapp");
+  if (!service || typeof service.handleWebhook !== "function") {
+    res.status(503).json({ error: "WhatsApp service unavailable" });
+    return;
+  }
+  const body = req.body;
+  if (!body) {
+    res.status(400).json({ error: "Missing request body" });
+    return;
+  }
+  await service.handleWebhook(body);
+  res.status(200).json("EVENT_RECEIVED");
+}
+async function handlePair(req, res, runtime) {
+  cleanupStaleSessions();
+  const setupService = getSetupService(runtime);
+  const body = req.body;
+  let accountId;
+  try {
+    accountId = sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+    return;
+  }
+  const isReplacing = whatsappPairingSessions.has(accountId);
+  if (!isReplacing && whatsappPairingSessions.size >= MAX_PAIRING_SESSIONS) {
+    res.status(429).json({
+      error: `Too many concurrent pairing sessions (max ${MAX_PAIRING_SESSIONS})`
+    });
+    return;
+  }
+  const workspaceDir = setupService?.getWorkspaceDir() ?? ".";
+  const authDir = path2.join(workspaceDir, "whatsapp-auth", accountId);
+  whatsappPairingSessions.get(accountId)?.stop();
+  const session = new WhatsAppPairingSession({
+    authDir,
+    accountId,
+    onEvent: (event) => {
+      setupService?.broadcastWs(event);
+      if (event.status === "connected") {
+        if (setupService) {
+          setupService.updateConfig((config) => {
+            if (!config.connectors)
+              config.connectors = {};
+            const connectors = config.connectors;
+            connectors.whatsapp = {
+              ...connectors.whatsapp ?? {},
+              authDir,
+              enabled: true
+            };
+          });
+          const phoneNumber = event.phoneNumber;
+          setupService.setOwnerContact({
+            source: "whatsapp",
+            channelId: phoneNumber ?? undefined
+          });
+        }
+      }
+    }
+  });
+  whatsappPairingSessions.set(accountId, session);
+  try {
+    await session.start();
+    res.status(200).json({ ok: true, accountId, status: session.getStatus() });
+  } catch (err) {
+    res.status(500).json({ ok: false, error: String(err) });
+  }
+}
+async function handleStatus(req, res, runtime) {
+  cleanupStaleSessions();
+  const setupService = getSetupService(runtime);
+  const url = new URL(req.url ?? "/", `http://${req.headers?.host ?? "localhost"}`);
+  let accountId;
+  try {
+    accountId = sanitizeAccountId(url.searchParams.get("accountId") || "default");
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+    return;
+  }
+  const session = whatsappPairingSessions.get(accountId);
+  const workspaceDir = setupService?.getWorkspaceDir() ?? ".";
+  let serviceConnected = false;
+  let servicePhone = null;
+  try {
+    const waService = runtime.getService("whatsapp");
+    if (waService && typeof waService === "object") {
+      const waState = waService;
+      serviceConnected = Boolean(waState.connected);
+      servicePhone = typeof waState.phoneNumber === "string" ? waState.phoneNumber : null;
+    }
+  } catch {}
+  res.status(200).json({
+    accountId,
+    status: session?.getStatus() ?? "idle",
+    authExists: whatsappAuthExists(workspaceDir, accountId),
+    serviceConnected,
+    servicePhone
+  });
+}
+async function handlePairStop(req, res, _runtime) {
+  const body = req.body;
+  let accountId;
+  try {
+    accountId = sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+    return;
+  }
+  const session = whatsappPairingSessions.get(accountId);
+  if (session) {
+    session.stop();
+    whatsappPairingSessions.delete(accountId);
+  }
+  res.status(200).json({ ok: true, accountId, status: "idle" });
+}
+async function handleDisconnect(req, res, runtime) {
+  const setupService = getSetupService(runtime);
+  const body = req.body;
+  let accountId;
+  try {
+    accountId = sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+    return;
+  }
+  const session = whatsappPairingSessions.get(accountId);
+  if (session) {
+    session.stop();
+    whatsappPairingSessions.delete(accountId);
+  }
+  const workspaceDir = setupService?.getWorkspaceDir() ?? ".";
+  try {
+    await whatsappLogout(workspaceDir, accountId);
+  } catch (logoutErr) {
+    console.warn(`[whatsapp] Logout failed for ${accountId}, deleting auth files directly:`, String(logoutErr));
+    const authDir = path2.join(workspaceDir, "whatsapp-auth", accountId);
+    try {
+      fs2.rmSync(authDir, { recursive: true, force: true });
+    } catch {}
+  }
+  if (setupService) {
+    setupService.updateConfig((config) => {
+      const connectors = config.connectors;
+      if (connectors) {
+        delete connectors.whatsapp;
+      }
+    });
+  }
+  res.status(200).json({ ok: true, accountId });
+}
+var whatsappSetupRoutes = [
+  {
+    name: "whatsapp-webhook-verify",
+    type: "GET",
+    path: "/api/whatsapp/webhook",
+    handler: handleWebhookVerify,
+    rawPath: true,
+    public: true
+  },
+  {
+    name: "whatsapp-webhook-event",
+    type: "POST",
+    path: "/api/whatsapp/webhook",
+    handler: handleWebhookEvent,
+    rawPath: true,
+    public: true
+  },
+  {
+    type: "POST",
+    path: "/api/whatsapp/pair",
+    handler: handlePair,
+    rawPath: true
+  },
+  {
+    type: "GET",
+    path: "/api/whatsapp/status",
+    handler: handleStatus,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/whatsapp/pair/stop",
+    handler: handlePairStop,
+    rawPath: true
+  },
+  {
+    type: "POST",
+    path: "/api/whatsapp/disconnect",
+    handler: handleDisconnect,
+    rawPath: true
+  }
+];
+function stopAllPairingSessions() {
+  for (const session of whatsappPairingSessions.values()) {
+    try {
+      session.stop();
+    } catch {}
+  }
+  whatsappPairingSessions.clear();
+}
+// 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/factory.ts
+var ClientFactory = {
+  create(config) {
+    const authMethod = detectAuthMethod(config);
+    if (authMethod === "baileys") {
+      return new BaileysClient(config);
+    }
+    return new WhatsAppClient(config);
+  }
+};
+// 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
+var whatsappPlugin = {
+  name: "whatsapp",
+  description: "WhatsApp integration for ElizaOS (Cloud API + Baileys)",
+  actions: [sendMessageAction, sendReactionAction],
+  services: [WhatsAppConnectorService],
+  routes: whatsappSetupRoutes
+};
+var src_default = whatsappPlugin;
+export {
+  whatsappSetupRoutes,
+  whatsappLogout,
+  whatsappAuthExists,
+  truncateText,
+  stopAllPairingSessions,
+  sanitizeAccountId as sanitizeWhatsAppAccountId,
+  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,
+  WhatsAppPairingSession,
+  WhatsAppEventType,
+  WhatsAppConnectorService,
+  WHATSAPP_TEXT_CHUNK_LIMIT,
+  WHATSAPP_REACTIONS,
+  DEFAULT_ACCOUNT_ID,
+  ClientFactory
+};
+
+//# debugId=60D99E2A9F2E72FB64756E2164756E21
+//# sourceMappingURL=index.js.map