@elizaos/plugin-whatsapp 2.0.0-alpha.9 → 2.0.3-beta.5

package/dist/index.js

@@ -1,385 +1,378 @@
-// 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}}
+import { createRequire } from "node:module";
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
-Based on the conversation, extract the message parameters.
+// src/index.ts
+import { getConnectorAccountManager, logger as logger2 } from "@elizaos/core";
 
-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 = /\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."
-        });
+// 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,
+    transport: characterWhatsApp?.transport,
+    authDir: characterWhatsApp?.authDir,
+    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 envAuthDir = runtime.getSetting("WHATSAPP_AUTH_DIR") ?? runtime.getSetting("WHATSAPP_SESSION_PATH");
+  const baseConfigured = Boolean(config.accessToken?.trim() && config.phoneNumberId?.trim());
+  const envConfigured = Boolean(envToken?.trim() && envPhoneId?.trim());
+  const baileysConfigured = Boolean(config.authDir?.trim() || envAuthDir?.trim());
+  if (baseConfigured || envConfigured || baileysConfigured) {
+    ids.add(DEFAULT_ACCOUNT_ID);
+  }
+  if (accounts && typeof accounts === "object") {
+    for (const id of Object.keys(accounts)) {
+      if (id) {
+        ids.add(normalizeAccountId(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" };
+  }
+  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" };
     }
-    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 };
+    const envToken = runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+    if (envToken?.trim()) {
+      return { token: envToken.trim(), source: "env" };
     }
-  },
-  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 = /\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 { 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 envAuthDir = runtime.getSetting("WHATSAPP_AUTH_DIR") ?? runtime.getSetting("WHATSAPP_SESSION_PATH");
+  const envTransport = runtime.getSetting("WHATSAPP_AUTH_METHOD");
+  const envConfig = {
+    transport: envTransport,
+    authDir: envAuthDir || undefined,
+    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;
     }
-    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;
+    if (policy2 === "open") {
+      return true;
     }
-  },
-  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" };
+    if (groupConfig?.allowFrom?.length) {
+      return groupConfig.allowFrom.some((allowed) => String(allowed) === identifier);
     }
-    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" };
+    if (accountConfig.groupAllowFrom?.length) {
+      return accountConfig.groupAllowFrom.some((allowed) => String(allowed) === identifier);
     }
-    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" };
+    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 };
     }
-    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 };
+    if (policy2 === "open") {
+      return { allowed: true };
     }
-  },
-  examples: [
-    [
-      {
-        name: "{{name1}}",
-        content: {
-          text: "React with a thumbs up"
-        }
-      },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "I'll add that reaction.",
-          actions: [WHATSAPP_SEND_REACTION_ACTION]
-        }
+    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/connector-account-provider.ts
+var WHATSAPP_PROVIDER_ID = "whatsapp";
+function purposeForAccount(_account) {
+  return ["messaging"];
+}
+function accessGateForAccount(account) {
+  const dmPolicy = account.config.dmPolicy;
+  if (dmPolicy === "disabled")
+    return "disabled";
+  if (dmPolicy === "pairing")
+    return "pairing";
+  return "open";
+}
+function roleForAccount(_account) {
+  return "AGENT";
+}
+function toConnectorAccount(account) {
+  const now = Date.now();
+  return {
+    id: normalizeAccountId(account.accountId),
+    provider: WHATSAPP_PROVIDER_ID,
+    label: account.name ?? account.accountId,
+    role: roleForAccount(account),
+    purpose: purposeForAccount(account),
+    accessGate: accessGateForAccount(account),
+    status: account.enabled && account.configured ? "connected" : "disabled",
+    externalId: account.phoneNumberId || undefined,
+    displayHandle: account.phoneNumberId || undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      tokenSource: account.tokenSource,
+      phoneNumberId: account.phoneNumberId,
+      businessAccountId: account.businessAccountId ?? null,
+      dmPolicy: account.config.dmPolicy ?? "pairing",
+      groupPolicy: account.config.groupPolicy ?? "allowlist"
+    }
+  };
+}
+function createWhatsAppConnectorAccountProvider(runtime) {
+  return {
+    provider: WHATSAPP_PROVIDER_ID,
+    label: "WhatsApp",
+    listAccounts: async (_manager) => {
+      const enabled = listEnabledWhatsAppAccounts(runtime);
+      if (enabled.length > 0) {
+        return enabled.map(toConnectorAccount);
       }
-    ]
-  ]
-};
+      const fallback = resolveWhatsAppAccount(runtime, DEFAULT_ACCOUNT_ID);
+      return [toConnectorAccount(fallback)];
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: WHATSAPP_PROVIDER_ID,
+        role: input.role ?? "AGENT",
+        purpose: input.purpose ?? ["messaging"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: WHATSAPP_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
+}
+
+// src/runtime-service.ts
+import {
+  ChannelType,
+  createUniqueUuid,
+  lifeOpsPassiveConnectorsEnabled,
+  Service
+} from "@elizaos/core";
+
 // src/client.ts
 import { EventEmitter } from "node:events";
-import axios from "axios";
+
+// src/media.ts
+var ALLOWED_MEDIA_PROTOCOLS = new Set(["http:", "https:"]);
+function mediaLinkError(kind) {
+  return new Error(`${kind} message requires a valid http(s) media link`);
+}
+function assertValidWhatsAppMediaLink(link, kind) {
+  if (typeof link !== "string" || !link.trim()) {
+    throw mediaLinkError(kind);
+  }
+  let url;
+  try {
+    url = new URL(link.trim());
+  } catch {
+    throw mediaLinkError(kind);
+  }
+  if (!ALLOWED_MEDIA_PROTOCOLS.has(url.protocol) || url.username || url.password || !url.hostname) {
+    throw mediaLinkError(kind);
+  }
+  return url.toString();
+}
+
+// src/client.ts
 var DEFAULT_API_VERSION = "v24.0";
 
 class WhatsAppClient extends EventEmitter {
-  client;
+  baseUrl;
+  headers;
   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"
-      }
-    });
+    this.baseUrl = `https://graph.facebook.com/${apiVersion}`;
+    this.headers = {
+      Authorization: `Bearer ${config.accessToken}`,
+      "Content-Type": "application/json"
+    };
   }
   async start() {
     this.connectionStatus = "open";
@@ -399,7 +392,7 @@ class WhatsAppClient extends EventEmitter {
   async sendMessage(message) {
     const endpoint = `/${this.config.phoneNumberId}/messages`;
     const payload = this.buildMessagePayload(message);
-    return this.client.post(endpoint, payload);
+    return this.post(endpoint, payload);
   }
   async sendTextMessage(to, text, _previewUrl = false) {
     return this.sendMessage({
@@ -421,10 +414,10 @@ class WhatsAppClient extends EventEmitter {
       }
     };
     try {
-      const response = await this.client.post(endpoint, payload);
+      const response = await this.post(endpoint, payload);
       return {
         success: true,
-        messageId: response.data.messages?.[0]?.id
+        messageId: response.data.messages[0]?.id
       };
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
@@ -545,7 +538,7 @@ class WhatsAppClient extends EventEmitter {
       message_id: messageId
     };
     try {
-      await this.client.post(endpoint, payload);
+      await this.post(endpoint, payload);
       return true;
     } catch {
       return false;
@@ -553,7 +546,7 @@ class WhatsAppClient extends EventEmitter {
   }
   async getMediaUrl(mediaId) {
     try {
-      const response = await this.client.get(`/${mediaId}`);
+      const response = await this.get(`/${mediaId}`);
       return response.data.url || null;
     } catch {
       return null;
@@ -562,6 +555,44 @@ class WhatsAppClient extends EventEmitter {
   async verifyWebhook(token) {
     return token === this.config.webhookVerifyToken;
   }
+  get(endpoint) {
+    return this.request(endpoint, { method: "GET" });
+  }
+  post(endpoint, payload) {
+    return this.request(endpoint, {
+      method: "POST",
+      body: JSON.stringify(payload)
+    });
+  }
+  async request(endpoint, init) {
+    const normalizedEndpoint = endpoint.startsWith("/") ? endpoint.slice(1) : endpoint;
+    const response = await fetch(`${this.baseUrl}/${normalizedEndpoint}`, {
+      ...init,
+      headers: {
+        ...this.headers,
+        ...init.headers
+      }
+    });
+    const text = await response.text();
+    const data = text ? this.parseResponseBody(text) : undefined;
+    if (!response.ok) {
+      const detail = typeof data === "string" ? data : data ? JSON.stringify(data) : response.statusText;
+      throw new Error(`WhatsApp Cloud API request failed (${response.status} ${response.statusText}): ${detail}`);
+    }
+    return {
+      data,
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    };
+  }
+  parseResponseBody(text) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return text;
+    }
+  }
   buildMessagePayload(message) {
     const basePayload = {
       messaging_product: "whatsapp",
@@ -591,7 +622,7 @@ class WhatsAppClient extends EventEmitter {
           ...basePayload,
           ...contextPayload,
           image: {
-            link: imageContent.link,
+            link: assertValidWhatsAppMediaLink(imageContent.link, "image"),
             caption: imageContent.caption
           }
         };
@@ -602,7 +633,7 @@ class WhatsAppClient extends EventEmitter {
           ...basePayload,
           ...contextPayload,
           video: {
-            link: videoContent.link,
+            link: assertValidWhatsAppMediaLink(videoContent.link, "video"),
             caption: videoContent.caption
           }
         };
@@ -613,7 +644,7 @@ class WhatsAppClient extends EventEmitter {
           ...basePayload,
           ...contextPayload,
           audio: {
-            link: audioContent.link
+            link: assertValidWhatsAppMediaLink(audioContent.link, "audio")
           }
         };
       }
@@ -623,7 +654,7 @@ class WhatsAppClient extends EventEmitter {
           ...basePayload,
           ...contextPayload,
           document: {
-            link: docContent.link,
+            link: assertValidWhatsAppMediaLink(docContent.link, "document"),
             filename: docContent.filename,
             caption: docContent.caption
           }
@@ -666,24 +697,6 @@ class WhatsAppClient extends EventEmitter {
   }
 }
 
-// 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";
 
@@ -712,9 +725,7 @@ class BaileysAuthManager {
 
 // src/baileys/connection.ts
 import { EventEmitter as EventEmitter2 } from "node:events";
-import makeWASocket, {
-  DisconnectReason
-} from "@whiskeysockets/baileys";
+import makeWASocket, { DisconnectReason } from "@whiskeysockets/baileys";
 import pino from "pino";
 
 class BaileysConnection extends EventEmitter2 {
@@ -807,8 +818,9 @@ class BaileysConnection extends EventEmitter2 {
     if (!this.socket) {
       return;
     }
-    this.socket.ev.removeAllListeners();
-    this.socket.ws?.close?.();
+    const socket = this.socket;
+    socket.ev.removeAllListeners();
+    socket.ws.close();
     this.socket = undefined;
     this.connectionStatus = "close";
     this.emit("connection", "close");
@@ -817,13 +829,18 @@ class BaileysConnection extends EventEmitter2 {
 
 // src/baileys/message-adapter.ts
 class MessageAdapter {
-  toUnified(msg) {
+  toNormalized(msg) {
+    const chatId = msg.key?.remoteJid ?? "";
+    const senderId = msg.key?.participant ?? chatId;
     return {
       id: msg.key?.id ?? "",
-      from: msg.key?.remoteJid ?? "",
+      from: chatId,
       timestamp: Number(msg.messageTimestamp ?? 0),
       type: this.detectType(msg),
-      content: this.extractContent(msg)
+      content: this.extractContent(msg),
+      chatId,
+      senderId,
+      replyToId: this.extractReplyToId(msg)
     };
   }
   toBaileys(msg) {
@@ -841,30 +858,24 @@ class MessageAdapter {
       case "template":
         return { text: this.renderTemplate(msg.content) };
       default:
-        throw new Error(`Message type ${msg.type} is not yet supported for Baileys`);
+        throw new Error(`Message type ${msg.type} is outside the Baileys adapter contract`);
     }
   }
   mediaWithCaption(key, media) {
-    if (!media?.link) {
-      throw new Error(`${key} message requires a media link`);
-    }
+    const link = assertValidWhatsAppMediaLink(media.link, key);
     return {
-      [key]: { url: media.link },
+      [key]: { url: 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 } };
+    const link = assertValidWhatsAppMediaLink(media.link, key);
+    return { [key]: { url: link } };
   }
   mediaWithFilename(media) {
-    if (!media?.link) {
-      throw new Error("document message requires a media link");
-    }
+    const link = assertValidWhatsAppMediaLink(media.link, "document");
     return {
-      document: { url: media.link },
+      document: { url: link },
       ...media.filename ? { fileName: media.filename } : {},
       ...media.caption ? { caption: media.caption } : {}
     };
@@ -888,7 +899,11 @@ class MessageAdapter {
     return "text";
   }
   extractContent(msg) {
-    return msg.message?.conversation ?? msg.message?.extendedTextMessage?.text ?? "";
+    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));
@@ -898,7 +913,7 @@ class MessageAdapter {
 
 // src/baileys/qr-code.ts
 import QRCode from "qrcode";
-import QRCodeTerminal from "qrcode-terminal";
+import * as QRCodeTerminal from "qrcode-terminal";
 
 class QRCodeGenerator {
   async generate(qrString) {
@@ -958,7 +973,7 @@ class BaileysClient extends EventEmitter3 {
       for (const message of messages) {
         const maybe = message;
         if (!maybe.key?.fromMe && maybe.message) {
-          this.emit("message", this.adapter.toUnified(message));
+          this.emit("message", this.adapter.toNormalized(message));
         }
       }
     });
@@ -989,514 +1004,2143 @@ class BaileysClient extends EventEmitter3 {
   getConnectionStatus() {
     return this.connection.getStatus();
   }
+  getPhoneNumber() {
+    return this.connection.getSocket()?.user?.id?.split(":")[0] ?? null;
+  }
 }
 
-// src/clients/factory.ts
-class ClientFactory {
-  static create(config) {
-    const authMethod = detectAuthMethod(config);
-    if (authMethod === "baileys") {
-      return new BaileysClient(config);
+// 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;
     }
-    return new WhatsAppClient(config);
   }
 }
+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/handlers/message.handler.ts
-class MessageHandler {
-  client;
-  constructor(client) {
-    this.client = client;
+// src/runtime-service.ts
+function readStringSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  if (typeof value === "string" && value.trim().length > 0) {
+    return value.trim();
   }
-  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");
-    }
+  const envValue = process.env[key];
+  if (typeof envValue === "string" && envValue.trim().length > 0) {
+    return envValue.trim();
   }
+  return;
 }
-// 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);
+function readCsvSetting(runtime, key) {
+  const value = readStringSetting(runtime, key);
+  if (!value) {
+    return [];
   }
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
 }
-// 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;
+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 {
+      accountId: DEFAULT_ACCOUNT_ID,
+      transport: "baileys",
+      authDir,
+      dmPolicy,
+      groupPolicy,
+      allowFrom,
+      groupAllowFrom
+    };
   }
-  const trimmed = accountId.trim().toLowerCase();
-  if (!trimmed || trimmed === "default") {
-    return DEFAULT_ACCOUNT_ID;
+  const accessToken = readStringSetting(runtime, "WHATSAPP_ACCESS_TOKEN");
+  const phoneNumberId = readStringSetting(runtime, "WHATSAPP_PHONE_NUMBER_ID");
+  if (accessToken && phoneNumberId) {
+    return {
+      accountId: DEFAULT_ACCOUNT_ID,
+      transport: "cloudapi",
+      accessToken,
+      phoneNumberId,
+      webhookVerifyToken: readStringSetting(runtime, "WHATSAPP_WEBHOOK_VERIFY_TOKEN"),
+      apiVersion: readStringSetting(runtime, "WHATSAPP_API_VERSION"),
+      dmPolicy,
+      groupPolicy,
+      allowFrom,
+      groupAllowFrom
+    };
   }
-  return trimmed;
+  return null;
 }
-function getMultiAccountConfig(runtime) {
-  const characterWhatsApp = runtime.character?.settings?.whatsapp;
+function configuredAccountForId(config, accountId) {
+  const normalized = normalizeAccountId(accountId);
+  const accountConfig = config.accounts?.[accountId] ?? Object.entries(config.accounts ?? {}).find(([key]) => normalizeAccountId(key) === normalized)?.[1] ?? {};
   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
+    ...config,
+    accounts: undefined,
+    groups: undefined,
+    ...accountConfig
   };
 }
-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));
-      }
+function resolveRuntimeConfigs(runtime) {
+  const multiConfig = getMultiAccountConfig(runtime);
+  const accountIds = listWhatsAppAccountIds(runtime);
+  const configs = [];
+  for (const accountId of accountIds) {
+    const normalizedAccountId = normalizeAccountId(accountId);
+    const accountConfig = configuredAccountForId(multiConfig, normalizedAccountId);
+    const authDir = accountConfig.authDir?.trim();
+    const transport = accountConfig.transport ?? (authDir ? "baileys" : "cloudapi");
+    if (transport === "baileys" && authDir) {
+      configs.push({
+        accountId: normalizedAccountId,
+        name: accountConfig.name?.trim() || undefined,
+        transport: "baileys",
+        authDir,
+        dmPolicy: accountConfig.dmPolicy,
+        groupPolicy: accountConfig.groupPolicy,
+        allowFrom: accountConfig.allowFrom?.map(String),
+        groupAllowFrom: accountConfig.groupAllowFrom?.map(String)
+      });
+      continue;
+    }
+    const cloud = resolveWhatsAppAccount(runtime, normalizedAccountId);
+    if (cloud.enabled && cloud.configured) {
+      configs.push({
+        accountId: normalizedAccountId,
+        name: cloud.name,
+        transport: "cloudapi",
+        accessToken: cloud.accessToken,
+        phoneNumberId: cloud.phoneNumberId,
+        businessAccountId: cloud.businessAccountId,
+        webhookVerifyToken: cloud.config.webhookVerifyToken,
+        apiVersion: cloud.config.apiVersion,
+        dmPolicy: cloud.config.dmPolicy,
+        groupPolicy: cloud.config.groupPolicy,
+        allowFrom: cloud.config.allowFrom?.map(String),
+        groupAllowFrom: cloud.config.groupAllowFrom?.map(String)
+      });
     }
   }
-  const result = Array.from(ids);
-  if (result.length === 0) {
-    return [DEFAULT_ACCOUNT_ID];
+  if (configs.length > 0) {
+    return configs;
   }
-  return result.slice().sort((a, b) => a.localeCompare(b));
+  const legacy = resolveRuntimeConfig(runtime);
+  return legacy ? [legacy] : [];
 }
-function resolveDefaultWhatsAppAccountId(runtime) {
-  const ids = listWhatsAppAccountIds(runtime);
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
-    return DEFAULT_ACCOUNT_ID;
+function toTimestampMs(value) {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return Date.now();
   }
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
+  return parsed >= 1000000000000 ? parsed : parsed * 1000;
 }
-function getAccountConfig(runtime, accountId) {
-  const config = getMultiAccountConfig(runtime);
-  const accounts = config.accounts;
-  if (!accounts || typeof accounts !== "object") {
+function toMemoryId(runtime, chatId, messageId) {
+  return createUniqueUuid(runtime, `whatsapp:${chatId}:${messageId}`);
+}
+function readTargetAccountId(target) {
+  return target?.accountId;
+}
+function readContextAccountId(context) {
+  return context?.accountId;
+}
+function targetWithAccount(target, accountId) {
+  return { ...target, accountId };
+}
+function registerMessageConnectorIfAvailable(runtime, registration) {
+  const withRegistry = runtime;
+  if (typeof withRegistry.registerMessageConnector === "function") {
+    withRegistry.registerMessageConnector(registration);
     return;
   }
-  const direct = accounts[accountId];
-  if (direct) {
-    return direct;
+  if (registration.sendHandler) {
+    runtime.registerSendHandler(registration.source, registration.sendHandler);
   }
-  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" };
+function normalizeBaileysSendTarget(target) {
+  if (isWhatsAppGroupJid(target) || isWhatsAppUserTarget(target)) {
+    return target;
   }
-  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" };
-    }
+  const normalized = normalizeWhatsAppTarget(target);
+  return normalized ? buildWhatsAppUserJid(normalized) : target;
+}
+function normalizeWhatsAppConnectorTarget(value) {
+  const trimmed = value.trim().replace(/^whatsapp:/i, "").trim();
+  if (!trimmed)
+    return "";
+  if (isWhatsAppGroupJid(trimmed) || isWhatsAppUserTarget(trimmed)) {
+    return trimmed;
   }
-  return { token: "", source: "none" };
+  return normalizeWhatsAppTarget(trimmed) ?? trimmed;
 }
-function filterDefined(obj) {
-  return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+function isWhatsAppAddress(value) {
+  return isWhatsAppGroupJid(value) || isWhatsAppUserTarget(value) || normalizeWhatsAppTarget(value) !== null;
 }
-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
-  };
+function normalizedSearchText(value) {
+  return (value ?? "").toLowerCase().replace(/[^a-z0-9@+._-]+/g, " ").trim();
+}
+function matchesQuery(query, ...values) {
+  const normalizedQuery = normalizedSearchText(query);
+  if (!normalizedQuery)
+    return true;
+  const normalizedTargetQuery = normalizedSearchText(normalizeWhatsAppConnectorTarget(query));
+  return values.some((value) => {
+    const normalizedValue = normalizedSearchText(value);
+    return normalizedValue.includes(normalizedQuery) || normalizedTargetQuery.length > 0 && normalizedValue.includes(normalizedTargetQuery);
+  });
+}
+function whatsappTargetKind(value) {
+  if (isWhatsAppGroupJid(value))
+    return "group";
+  if (/^\+?\d{7,}$/.test(value) || isWhatsAppUserTarget(value))
+    return "phone";
+  return "contact";
+}
+function knownWhatsAppTargetToConnectorTarget(known, score = 0.72) {
+  const accountId = known.accountId ?? DEFAULT_ACCOUNT_ID;
   return {
-    ...filterDefined(envConfig),
-    ...filterDefined(baseConfig),
-    ...filterDefined(accountConfig)
+    target: targetWithAccount({
+      source: "whatsapp",
+      channelId: known.chatId,
+      entityId: known.senderId,
+      roomId: known.roomId
+    }, accountId),
+    label: known.label,
+    kind: known.isGroup ? "group" : whatsappTargetKind(known.senderId),
+    description: known.isGroup ? "WhatsApp group chat" : "WhatsApp contact",
+    score,
+    metadata: {
+      accountId,
+      chatId: known.chatId,
+      senderId: known.senderId,
+      lastMessageAt: known.lastMessageAt
+    }
   };
 }
-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);
+function directWhatsAppTarget(value, accountId = DEFAULT_ACCOUNT_ID, score = 0.68) {
+  const normalized = normalizeWhatsAppConnectorTarget(value);
+  if (!normalized || !isWhatsAppAddress(normalized))
+    return null;
   return {
-    accountId: normalizedAccountId,
-    enabled,
-    name: merged.name?.trim() || undefined,
-    accessToken: token,
-    phoneNumberId,
-    businessAccountId: merged.businessAccountId?.trim() || undefined,
-    tokenSource,
-    configured,
-    config: merged
+    target: targetWithAccount({
+      source: "whatsapp",
+      channelId: normalized,
+      entityId: normalized
+    }, accountId),
+    label: normalized,
+    kind: whatsappTargetKind(normalized),
+    score,
+    metadata: {
+      accountId,
+      normalizedTarget: normalized
+    }
   };
 }
-function listEnabledWhatsAppAccounts(runtime) {
-  return listWhatsAppAccountIds(runtime).map((accountId) => resolveWhatsAppAccount(runtime, accountId)).filter((account) => account.enabled && account.configured);
+async function resolveWhatsAppSendTarget(runtime, service, target, fallbackAccountId) {
+  const targetAccountId = typeof service.resolveAccountId === "function" ? service.resolveAccountId(readTargetAccountId(target) ?? fallbackAccountId) : normalizeAccountId(readTargetAccountId(target) ?? fallbackAccountId);
+  if (target.channelId?.trim()) {
+    const normalized = normalizeWhatsAppConnectorTarget(target.channelId);
+    const known = service.getKnownTarget(normalized, targetAccountId) ?? service.findKnownChatByParticipant(normalized, targetAccountId);
+    if (known) {
+      return { accountId: known.accountId ?? targetAccountId, chatId: known.chatId };
+    }
+    return isWhatsAppAddress(normalized) ? { accountId: targetAccountId, chatId: normalized } : null;
+  }
+  if (target.entityId?.trim()) {
+    const normalized = normalizeWhatsAppConnectorTarget(target.entityId);
+    const known = service.findKnownChatByParticipant(normalized, targetAccountId);
+    if (known) {
+      return { accountId: known.accountId ?? targetAccountId, chatId: known.chatId };
+    }
+    return isWhatsAppAddress(normalized) ? { accountId: targetAccountId, chatId: normalized } : null;
+  }
+  if (target.roomId) {
+    const room = await runtime.getRoom(target.roomId);
+    if (room?.channelId) {
+      const normalized = normalizeWhatsAppConnectorTarget(room.channelId);
+      const known = service.getKnownTarget(normalized, targetAccountId) ?? service.findKnownChatByParticipant(normalized, targetAccountId);
+      if (known) {
+        return { accountId: known.accountId ?? targetAccountId, chatId: known.chatId };
+      }
+      return isWhatsAppAddress(normalized) ? { accountId: targetAccountId, chatId: normalized } : null;
+    }
+  }
+  return null;
 }
-function isMultiAccountEnabled(runtime) {
-  const accounts = listEnabledWhatsAppAccounts(runtime);
-  return accounts.length > 1;
+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 "";
 }
-function resolveWhatsAppGroupConfig(runtime, accountId, groupId) {
-  const multiConfig = getMultiAccountConfig(runtime);
-  const accountConfig = getAccountConfig(runtime, accountId);
-  const accountGroup = accountConfig?.groups?.[groupId];
-  if (accountGroup) {
-    return accountGroup;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function asRecordArray(value) {
+  return Array.isArray(value) ? value.filter(isRecord) : [];
+}
+function isWebhookMessage(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Boolean(typeof value.from === "string" && value.from.trim() && typeof value.id === "string");
+}
+
+class WhatsAppConnectorService extends Service {
+  static serviceType = "whatsapp";
+  capabilityDescription = "The agent is able to send and receive messages on whatsapp";
+  connected = false;
+  phoneNumber = null;
+  defaultAccountId = DEFAULT_ACCOUNT_ID;
+  clients = new Map;
+  configs = new Map;
+  phoneNumbers = new Map;
+  client = null;
+  config = undefined;
+  knownTargets = new Map;
+  constructor(runtime) {
+    super(runtime);
+    if (runtime) {
+      this.runtime = runtime;
+    }
+  }
+  resolveAccountId(accountId) {
+    return normalizeAccountId(accountId ?? this.defaultAccountId);
+  }
+  getClientForAccount(accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    return this.clients.get(normalizedAccountId) ?? (normalizedAccountId === this.defaultAccountId ? this.client : null);
+  }
+  getConfigForAccount(accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    return this.configs.get(normalizedAccountId) ?? (normalizedAccountId === this.defaultAccountId ? this.config ?? null : null);
+  }
+  getConnectorAccountIds() {
+    const ids = Array.from(this.configs.keys());
+    return ids.length > 0 ? ids : [this.defaultAccountId];
+  }
+  targetKey(chatId, accountId) {
+    return `${this.resolveAccountId(accountId)}:${normalizeWhatsAppConnectorTarget(chatId)}`;
+  }
+  roomIdFor(chatId, accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    return createUniqueUuid(this.runtime, normalizedAccountId === DEFAULT_ACCOUNT_ID ? `whatsapp-room:${chatId}` : `whatsapp-room:${normalizedAccountId}:${chatId}`);
+  }
+  entityIdFor(senderId, accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    return createUniqueUuid(this.runtime, normalizedAccountId === DEFAULT_ACCOUNT_ID ? `whatsapp-entity:${senderId}` : `whatsapp-entity:${normalizedAccountId}:${senderId}`);
+  }
+  worldIdFor(chatId, accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    return createUniqueUuid(this.runtime, normalizedAccountId === DEFAULT_ACCOUNT_ID ? `whatsapp-world:${chatId}` : `whatsapp-world:${normalizedAccountId}:${chatId}`);
+  }
+  metadataMatchesAccount(memory, accountId) {
+    const metadata = memory.metadata;
+    const memoryAccountId = typeof metadata?.accountId === "string" && metadata.accountId.trim() ? this.resolveAccountId(metadata.accountId) : undefined;
+    return memoryAccountId ? memoryAccountId === accountId : accountId === DEFAULT_ACCOUNT_ID;
+  }
+  static async start(runtime) {
+    const service = new WhatsAppConnectorService(runtime);
+    await service.initialize();
+    return service;
+  }
+  static registerSendHandlers(runtime, service) {
+    const resolveServiceAccountId = (accountId) => typeof service.resolveAccountId === "function" ? service.resolveAccountId(accountId) : normalizeAccountId(accountId);
+    const getServiceConfigForAccount = (accountId) => typeof service.getConfigForAccount === "function" ? service.getConfigForAccount(accountId) : service.config ?? null;
+    const accountIds = typeof service.getConnectorAccountIds === "function" ? service.getConnectorAccountIds() : [DEFAULT_ACCOUNT_ID];
+    const registrationAccountIds = accountIds.length > 1 ? accountIds : [undefined];
+    for (const registrationAccountId of registrationAccountIds) {
+      const connectorAccountId = resolveServiceAccountId(registrationAccountId);
+      const config = getServiceConfigForAccount(connectorAccountId);
+      registerMessageConnectorIfAvailable(runtime, {
+        source: "whatsapp",
+        ...registrationAccountId ? { accountId: connectorAccountId } : {},
+        label: registrationAccountId && connectorAccountId !== DEFAULT_ACCOUNT_ID ? `WhatsApp (${connectorAccountId})` : "WhatsApp",
+        capabilities: [
+          "send_message",
+          "read_messages",
+          "search_messages",
+          "send_reaction",
+          "contact_resolution",
+          "chat_context",
+          "get_user"
+        ],
+        supportedTargetKinds: ["phone", "contact", "user", "group", "room"],
+        contexts: ["phone", "social", "connectors"],
+        description: "Send, read, search, and react in WhatsApp conversations through Cloud API or Baileys using phone numbers, JIDs, known contacts, or group ids.",
+        metadata: {
+          aliases: ["whatsapp", "wa"],
+          accountId: connectorAccountId,
+          transport: config?.transport ?? service.config?.transport ?? "unconfigured",
+          connected: service.connected
+        },
+        sendHandler: async (_runtime, target, content) => {
+          const text = typeof content.text === "string" ? content.text.trim() : "";
+          const attachments = Array.isArray(content.attachments) ? content.attachments.filter((media) => typeof media?.url === "string" && media.url.trim().length > 0) : [];
+          if (!text && attachments.length === 0) {
+            return;
+          }
+          const resolved = await resolveWhatsAppSendTarget(runtime, service, target, connectorAccountId);
+          if (!resolved) {
+            throw new Error("WhatsApp target is missing a phone number, JID, or chat id");
+          }
+          let replyToMessageId;
+          if (typeof content.inReplyTo === "string" && content.inReplyTo.trim()) {
+            const repliedToMemory = await runtime.getMemoryById(content.inReplyTo);
+            const metadata = repliedToMemory?.metadata;
+            const externalMessageId = metadata?.messageIdFull ?? metadata?.externalMessageId ?? metadata?.whatsappMessageId;
+            if (typeof externalMessageId === "string" && externalMessageId.trim()) {
+              replyToMessageId = externalMessageId.trim();
+            }
+          }
+          if (text) {
+            for (const chunk of chunkWhatsAppText(text)) {
+              await service.sendMessage({
+                accountId: resolved.accountId,
+                type: "text",
+                to: resolved.chatId,
+                content: chunk,
+                replyToMessageId
+              });
+            }
+          }
+          for (const media of attachments) {
+            try {
+              await service.sendMediaMessage(resolved.accountId, resolved.chatId, media);
+            } catch (error) {
+              runtime.logger.warn({
+                src: "plugin:whatsapp",
+                agentId: runtime.agentId,
+                url: media.url,
+                error: error instanceof Error ? error.message : String(error)
+              }, "Failed to send WhatsApp outbound attachment; skipping");
+            }
+          }
+        },
+        resolveTargets: async (query) => {
+          const candidates = [];
+          for (const known of service.listKnownTargets(connectorAccountId)) {
+            if (matchesQuery(query, known.label, known.chatId, known.senderId)) {
+              candidates.push(knownWhatsAppTargetToConnectorTarget(known, 0.82));
+            }
+          }
+          const direct = directWhatsAppTarget(query, connectorAccountId, 0.74);
+          if (direct)
+            candidates.push(direct);
+          return candidates;
+        },
+        listRecentTargets: () => service.listKnownTargets(connectorAccountId).map((known) => knownWhatsAppTargetToConnectorTarget(known, 0.66)),
+        listRooms: () => service.listKnownTargets(connectorAccountId).filter((known) => known.isGroup).map((known) => knownWhatsAppTargetToConnectorTarget(known, 0.7)),
+        fetchMessages: service.fetchConnectorMessages.bind(service),
+        searchMessages: service.searchConnectorMessages.bind(service),
+        reactHandler: service.reactConnectorMessage.bind(service),
+        getUser: service.getConnectorUser.bind(service),
+        getChatContext: async (target, context) => {
+          const resolved = await resolveWhatsAppSendTarget(context.runtime, service, target, readContextAccountId(context) ?? connectorAccountId);
+          if (!resolved)
+            return null;
+          const known = service.getKnownTarget(resolved.chatId, resolved.accountId) ?? service.findKnownChatByParticipant(resolved.chatId, resolved.accountId);
+          const resolvedConfig = getServiceConfigForAccount(resolved.accountId);
+          return {
+            target: targetWithAccount({ ...target, channelId: resolved.chatId }, resolved.accountId),
+            label: known?.label ?? resolved.chatId,
+            summary: known?.isGroup ? "WhatsApp group chat." : "WhatsApp direct chat.",
+            metadata: {
+              accountId: resolved.accountId,
+              chatId: resolved.chatId,
+              senderId: known?.senderId,
+              lastMessageAt: known?.lastMessageAt,
+              connected: service.connected,
+              transport: resolvedConfig?.transport
+            }
+          };
+        },
+        getUserContext: async (entityId) => {
+          const handle = normalizeWhatsAppConnectorTarget(String(entityId));
+          if (!handle)
+            return null;
+          const known = service.findKnownChatByParticipant(handle, connectorAccountId);
+          return {
+            entityId,
+            label: known?.label ?? handle,
+            aliases: known ? [known.label, known.senderId, known.chatId] : [handle],
+            handles: {
+              whatsapp: known?.chatId ?? handle,
+              phone: normalizeWhatsAppTarget(handle) ?? handle
+            },
+            metadata: {
+              accountId: known?.accountId ?? connectorAccountId,
+              normalizedHandle: handle,
+              chatId: known?.chatId
+            }
+          };
+        }
+      });
+    }
+  }
+  async initialize() {
+    this.defaultAccountId = resolveDefaultWhatsAppAccountId(this.runtime);
+    const configs = resolveRuntimeConfigs(this.runtime);
+    if (configs.length === 0) {
+      this.runtime.logger.warn({ src: "plugin:whatsapp", agentId: this.runtime.agentId }, "WhatsApp connector is not configured");
+      return;
+    }
+    for (const config of configs) {
+      const client = config.transport === "baileys" ? new BaileysClient({
+        authMethod: "baileys",
+        authDir: config.authDir,
+        printQRInTerminal: false
+      }) : new WhatsAppClient({
+        accessToken: config.accessToken,
+        phoneNumberId: config.phoneNumberId,
+        webhookVerifyToken: config.webhookVerifyToken,
+        apiVersion: config.apiVersion
+      });
+      this.configs.set(config.accountId, config);
+      this.clients.set(config.accountId, client);
+      if (config.accountId === this.defaultAccountId || !this.client) {
+        this.config = config;
+        this.client = client;
+      }
+      this.bindClientEvents(client, config.accountId);
+      await client.start();
+      if (config.transport === "cloudapi") {
+        this.connected = true;
+      }
+    }
+  }
+  async stop() {
+    for (const client of this.clients.values()) {
+      await client.stop();
+    }
+    this.clients.clear();
+    this.configs.clear();
+    this.phoneNumbers.clear();
+    this.client = null;
+    this.config = undefined;
+    this.connected = false;
+    this.phoneNumber = null;
+  }
+  async handleWebhook(event) {
+    for (const entry of asRecordArray(event?.entry)) {
+      for (const change of asRecordArray(entry.changes)) {
+        if (!isRecord(change.value)) {
+          continue;
+        }
+        const value = change.value;
+        const metadata = isRecord(value.metadata) ? value.metadata : {};
+        const phoneNumberId = typeof metadata.phone_number_id === "string" ? metadata.phone_number_id : undefined;
+        const accountId = this.resolveWebhookAccountId(phoneNumberId);
+        if (typeof metadata.display_phone_number === "string") {
+          this.phoneNumbers.set(accountId, metadata.display_phone_number);
+          if (accountId === this.defaultAccountId) {
+            this.phoneNumber = metadata.display_phone_number;
+          }
+        }
+        for (const message of asRecordArray(value.messages)) {
+          if (!isWebhookMessage(message)) {
+            continue;
+          }
+          await this.handleIncomingWebhookMessage(message, accountId);
+        }
+      }
+    }
+  }
+  verifyWebhook(mode, token, challenge, accountId) {
+    const configs = accountId ? [this.getConfigForAccount(accountId)].filter((config) => Boolean(config)) : Array.from(this.configs.values());
+    const expectedTokens = configs.length > 0 ? configs.filter((config) => config.transport === "cloudapi").map((config) => config.webhookVerifyToken) : [
+      this.config?.transport === "cloudapi" ? this.config.webhookVerifyToken : readStringSetting(this.runtime, "WHATSAPP_WEBHOOK_VERIFY_TOKEN")
+    ];
+    if (mode === "subscribe" && challenge && expectedTokens.some((expectedToken) => expectedToken && token === expectedToken)) {
+      return challenge;
+    }
+    return null;
+  }
+  resolveWebhookAccountId(phoneNumberId) {
+    const normalizedPhoneNumberId = typeof phoneNumberId === "string" && phoneNumberId.trim() ? phoneNumberId.trim() : undefined;
+    if (normalizedPhoneNumberId) {
+      for (const [accountId, config] of this.configs) {
+        if (config.transport === "cloudapi" && config.phoneNumberId === normalizedPhoneNumberId) {
+          return accountId;
+        }
+      }
+    }
+    return this.defaultAccountId;
+  }
+  bindClientEvents(client, accountId) {
+    client.on("connection", (status) => {
+      if (status === "open") {
+        this.connected = true;
+      }
+      if (status === "open" && client instanceof BaileysClient) {
+        const nextPhone = client.getPhoneNumber();
+        const normalizedPhone = (nextPhone && normalizeWhatsAppTarget(nextPhone)) ?? nextPhone;
+        if (normalizedPhone) {
+          this.phoneNumbers.set(accountId, normalizedPhone);
+        }
+        if (accountId === this.defaultAccountId) {
+          this.phoneNumber = normalizedPhone;
+        }
+      }
+      if (status === "close") {
+        this.phoneNumbers.delete(accountId);
+        this.connected = this.phoneNumbers.size > 0 || Array.from(this.configs.values()).some((config) => config.transport === "cloudapi");
+        if (accountId === this.defaultAccountId) {
+          this.phoneNumber = null;
+        }
+      }
+    });
+    client.on("ready", () => {
+      this.connected = true;
+      if (client instanceof BaileysClient) {
+        const nextPhone = client.getPhoneNumber();
+        const normalizedPhone = (nextPhone && normalizeWhatsAppTarget(nextPhone)) ?? nextPhone;
+        if (normalizedPhone) {
+          this.phoneNumbers.set(accountId, normalizedPhone);
+        }
+        if (accountId === this.defaultAccountId) {
+          this.phoneNumber = normalizedPhone;
+        }
+      }
+    });
+    client.on("message", (message) => {
+      this.handleNormalizedMessage(message, accountId).catch((error) => {
+        this.runtime.logger.error({
+          src: "plugin:whatsapp",
+          agentId: this.runtime.agentId,
+          accountId,
+          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,
+        accountId,
+        error: error instanceof Error ? error.message : String(error)
+      }, "WhatsApp client error");
+    });
+  }
+  async handleNormalizedMessage(message, accountId = this.defaultAccountId) {
+    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),
+      accountId
+    });
+  }
+  async handleIncomingWebhookMessage(message, accountId = this.defaultAccountId) {
+    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),
+      accountId
+    });
   }
-  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;
+  async processIncomingMessage(params) {
+    if (!this.runtime.messageService) {
+      throw new Error("WhatsApp connector requires runtime.messageService");
     }
-    if (policy2 === "open") {
-      return true;
+    const accountId = this.resolveAccountId(params.accountId);
+    const config = this.getConfigForAccount(accountId);
+    const isGroup = isWhatsAppGroupJid(params.chatId);
+    const normalizedSender = normalizeWhatsAppTarget(params.senderId) ?? params.senderId;
+    const accountConfig = {
+      dmPolicy: config?.dmPolicy,
+      groupPolicy: config?.groupPolicy,
+      allowFrom: config?.allowFrom,
+      groupAllowFrom: config?.groupAllowFrom
+    };
+    const access = await checkWhatsAppUserAccess({
+      runtime: this.runtime,
+      identifier: normalizedSender,
+      accountConfig,
+      isGroup,
+      ...isGroup ? { groupId: params.chatId } : {},
+      metadata: { accountId, senderId: normalizedSender }
+    });
+    if (!access.allowed) {
+      if (access.replyMessage) {
+        await this.sendTextMessage(params.chatId, access.replyMessage, undefined, accountId);
+      }
+      return;
     }
-    if (groupConfig?.allowFrom?.length) {
-      return groupConfig.allowFrom.some((allowed) => String(allowed) === identifier);
+    const channelType = isGroup ? ChannelType.GROUP : ChannelType.DM;
+    const roomId = this.roomIdFor(params.chatId, accountId);
+    const worldId = this.worldIdFor(params.chatId, accountId);
+    const entityId = this.entityIdFor(normalizedSender, accountId);
+    const inboundMemoryId = toMemoryId(this.runtime, accountId === DEFAULT_ACCOUNT_ID ? params.chatId : `${accountId}:${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
+      }),
+      metadata: {
+        accountId,
+        chatId: params.chatId,
+        isGroup
+      }
+    });
+    if (typeof this.runtime.ensureRoomExists === "function") {
+      await this.runtime.ensureRoomExists({
+        id: roomId,
+        name: resolveWhatsAppSystemLocation({
+          chatType: isGroup ? "group" : "user",
+          chatId: params.chatId
+        }),
+        agentId: this.runtime.agentId,
+        source: "whatsapp",
+        type: channelType,
+        channelId: params.chatId,
+        worldId,
+        metadata: {
+          accountId,
+          chatId: params.chatId,
+          isGroup
+        }
+      });
     }
-    if (accountConfig.groupAllowFrom?.length) {
-      return accountConfig.groupAllowFrom.some((allowed) => String(allowed) === identifier);
+    this.rememberTarget({
+      accountId,
+      chatId: params.chatId,
+      senderId: normalizedSender,
+      label: resolveWhatsAppSystemLocation({
+        chatType: isGroup ? "group" : "user",
+        chatId: params.chatId
+      }),
+      isGroup,
+      lastMessageAt: params.createdAt,
+      roomId
+    });
+    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, accountId === DEFAULT_ACCOUNT_ID ? params.chatId : `${accountId}:${params.chatId}`, params.replyToExternalMessageId)
+        } : {}
+      },
+      metadata: {
+        type: "message",
+        source: "whatsapp",
+        provider: "whatsapp",
+        accountId,
+        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: {
+          contactId: normalizedSender,
+          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, accountId);
+        const externalResponseId = response.messages[0]?.id ?? `${params.externalMessageId}:response:${index}:${Date.now()}`;
+        responseMemories.push({
+          id: toMemoryId(this.runtime, accountId === DEFAULT_ACCOUNT_ID ? params.chatId : `${accountId}:${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",
+            accountId,
+            timestamp: Date.now(),
+            fromBot: true,
+            fromId: this.runtime.agentId,
+            sourceId: this.runtime.agentId,
+            chatType: channelType,
+            messageIdFull: externalResponseId,
+            whatsapp: {
+              contactId: 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;
     }
-    return policy2 !== "allowlist";
-  }
-  const policy = accountConfig.dmPolicy ?? "pairing";
-  if (policy === "disabled") {
-    return false;
+    await this.runtime.messageService.handleMessage(this.runtime, inboundMemory, callback);
+  }
+  async sendTextMessage(chatId, text, replyToMessageId, accountId) {
+    const normalizedAccountId = this.resolveAccountId(accountId);
+    const client = this.getClientForAccount(normalizedAccountId);
+    const config = this.getConfigForAccount(normalizedAccountId);
+    if (!client || !config) {
+      throw new Error("WhatsApp client is not initialized");
+    }
+    const response = await client.sendMessage({
+      type: "text",
+      to: config.transport === "baileys" ? normalizeBaileysSendTarget(chatId) : normalizeWhatsAppTarget(chatId) ?? chatId,
+      content: text,
+      replyToMessageId
+    });
+    return "data" in response ? response.data : response;
   }
-  if (policy === "open") {
-    return true;
+  async sendMessage(message) {
+    return this.sendTextMessage(message.to, message.content, message.replyToMessageId, message.accountId);
   }
-  if (policy === "pairing") {
-    return true;
+  whatsappMediaType(media) {
+    const ct = (media.contentType ?? "").toLowerCase();
+    const mime = (media.mimeType ?? "").toLowerCase();
+    if (ct === "image" || mime.startsWith("image/"))
+      return "image";
+    if (ct === "video" || mime.startsWith("video/"))
+      return "video";
+    if (ct === "audio" || mime.startsWith("audio/"))
+      return "audio";
+    return "document";
   }
-  if (accountConfig.allowFrom?.length) {
-    return accountConfig.allowFrom.some((allowed) => String(allowed) === identifier);
+  async sendMediaMessage(accountId, to, media) {
+    if (!media.url)
+      return;
+    const client = this.getClientForAccount(accountId);
+    if (!client) {
+      throw new Error("WhatsApp client not initialized");
+    }
+    const type = this.whatsappMediaType(media);
+    const filename = media.filename ?? media.title ?? undefined;
+    const mediaContent = {
+      link: media.url,
+      ...media.description ? { caption: media.description } : {},
+      ...type === "document" && filename ? { filename } : {}
+    };
+    await client.sendMessage({ type, to, content: mediaContent });
   }
-  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 };
+  async fetchConnectorMessages(context, params) {
+    if (typeof this.runtime.getMemoriesByRoomIds !== "function") {
+      return [];
     }
-    if (policy2 === "open") {
-      return { allowed: true };
+    const target = params.target ?? context.target;
+    let accountId = this.resolveAccountId(readTargetAccountId(target) ?? readContextAccountId(context));
+    let chatId = params.channelId;
+    if (!chatId && target) {
+      const resolved = await resolveWhatsAppSendTarget(context.runtime, this, target, accountId);
+      if (resolved) {
+        accountId = resolved.accountId;
+        chatId = resolved.chatId;
+      }
     }
-    if (groupConfig?.allowFrom?.length) {
-      const allowed = groupConfig.allowFrom.some((a) => String(a) === identifier);
-      return { allowed };
+    if (!chatId && params.roomId) {
+      const room = await context.runtime.getRoom(params.roomId);
+      chatId = room?.channelId;
+      const metadata = room?.metadata;
+      if (typeof metadata?.accountId === "string") {
+        accountId = this.resolveAccountId(metadata.accountId);
+      }
     }
-    if (accountConfig.groupAllowFrom?.length) {
-      const allowed = accountConfig.groupAllowFrom.some((a) => String(a) === identifier);
-      return { allowed };
+    const knownTargets = chatId ? [
+      this.getKnownTarget(chatId, accountId) ?? this.findKnownChatByParticipant(chatId, accountId) ?? {
+        accountId,
+        chatId,
+        senderId: chatId,
+        label: chatId,
+        isGroup: isWhatsAppGroupJid(chatId),
+        lastMessageAt: 0,
+        roomId: this.roomIdFor(chatId, accountId)
+      }
+    ] : this.listKnownTargets(accountId);
+    const roomIds = knownTargets.map((known) => known.roomId ?? this.roomIdFor(known.chatId, known.accountId)).filter((roomId) => Boolean(roomId));
+    if (roomIds.length === 0) {
+      return [];
     }
-    return { allowed: policy2 !== "allowlist" };
-  }
-  const policy = accountConfig.dmPolicy ?? "pairing";
-  if (policy === "disabled") {
-    return { allowed: false };
-  }
-  if (policy === "open") {
-    return { allowed: true };
+    const limit = Number.isFinite(params.limit) ? Math.max(1, Math.min(Number(params.limit), 100)) : 25;
+    const memories = await this.runtime.getMemoriesByRoomIds({
+      tableName: "messages",
+      roomIds,
+      limit: limit * Math.max(roomIds.length, 1)
+    });
+    const chatIds = new Set(knownTargets.map((known) => normalizeWhatsAppConnectorTarget(known.chatId)));
+    const before = params.before ? Number(params.before) : undefined;
+    const after = params.after ? Number(params.after) : undefined;
+    return memories.filter((memory) => memory.content.source === "whatsapp").filter((memory) => this.metadataMatchesAccount(memory, accountId)).filter((memory) => {
+      const metadata = memory.metadata;
+      const rawChatId = typeof metadata?.rawChatId === "string" ? normalizeWhatsAppConnectorTarget(metadata.rawChatId) : undefined;
+      if (chatId && rawChatId && !chatIds.has(rawChatId)) {
+        return false;
+      }
+      const createdAt = Number(memory.createdAt ?? 0);
+      if (before !== undefined && Number.isFinite(before) && createdAt >= before) {
+        return false;
+      }
+      if (after !== undefined && Number.isFinite(after) && createdAt <= after) {
+        return false;
+      }
+      return true;
+    }).sort((left, right) => Number(right.createdAt ?? 0) - Number(left.createdAt ?? 0)).slice(0, limit);
   }
-  if (policy === "pairing") {
-    const result = await checkPairingAllowed(runtime, {
-      channel: "whatsapp",
-      senderId: identifier,
-      metadata
+  async searchConnectorMessages(context, params) {
+    const query = params.query?.trim().toLowerCase();
+    if (!query) {
+      return [];
+    }
+    const memories = await this.fetchConnectorMessages(context, {
+      ...params,
+      limit: Math.max(params.limit ?? 100, 100)
+    });
+    return memories.filter((memory) => {
+      const text = String(memory.content.text ?? "").toLowerCase();
+      const from = String(memory.content.from ?? "").toLowerCase();
+      return text.includes(query) || from.includes(query);
+    }).slice(0, params.limit ?? 25);
+  }
+  async reactConnectorMessage(runtime, params) {
+    const target = params.target;
+    const resolved = target ? await resolveWhatsAppSendTarget(runtime, this, target) : params.channelId ? { accountId: this.defaultAccountId, chatId: params.channelId } : null;
+    const accountId = this.resolveAccountId(resolved?.accountId ?? readTargetAccountId(target));
+    const client = this.getClientForAccount(accountId);
+    const config = this.getConfigForAccount(accountId);
+    if (!client || !config) {
+      throw new Error("WhatsApp client is not initialized");
+    }
+    const chatId = params.channelId ?? resolved?.chatId ?? (params.roomId ? (await runtime.getRoom(params.roomId))?.channelId : undefined);
+    if (!chatId) {
+      throw new Error("WhatsApp reaction requires a target chat.");
+    }
+    if (!params.messageId) {
+      throw new Error("WhatsApp reaction requires messageId.");
+    }
+    await client.sendMessage({
+      type: "reaction",
+      to: config.transport === "baileys" ? normalizeBaileysSendTarget(chatId) : normalizeWhatsAppTarget(chatId) ?? chatId,
+      content: {
+        messageId: params.messageId,
+        emoji: params.remove ? "" : params.emoji || "\uD83D\uDC4D"
+      }
     });
+  }
+  async getConnectorUser(_runtime, params) {
+    const lookup = params.userId ?? params.handle ?? params.username ?? params.query;
+    if (!lookup) {
+      return null;
+    }
+    const normalized = normalizeWhatsAppConnectorTarget(lookup);
+    const known = this.findKnownChatByParticipant(normalized) ?? this.getKnownTarget(normalized);
+    if (!known) {
+      return null;
+    }
     return {
-      allowed: result.allowed,
-      pairingCode: result.pairingCode,
-      newPairingRequest: result.newRequest,
-      replyMessage: result.replyMessage
+      id: this.entityIdFor(known.senderId, known.accountId),
+      agentId: this.runtime.agentId,
+      names: [known.label, known.senderId, known.chatId].filter((value) => typeof value === "string" && value.length > 0),
+      metadata: {
+        accountId: known.accountId,
+        source: "whatsapp",
+        whatsapp: {
+          accountId: known.accountId,
+          chatId: known.chatId,
+          senderId: known.senderId,
+          isGroup: known.isGroup
+        }
+      }
     };
   }
-  if (accountConfig.allowFrom?.length) {
-    const allowed = accountConfig.allowFrom.some((a) => String(a) === identifier);
-    if (allowed) {
-      return { allowed: true };
+  listKnownTargets(accountId) {
+    const normalizedAccountId = accountId ? this.resolveAccountId(accountId) : null;
+    return Array.from(this.knownTargets.values()).filter((target) => !normalizedAccountId || target.accountId === normalizedAccountId).sort((left, right) => right.lastMessageAt - left.lastMessageAt);
+  }
+  getKnownTarget(chatId, accountId) {
+    const normalized = normalizeWhatsAppConnectorTarget(chatId);
+    if (accountId) {
+      return this.knownTargets.get(this.targetKey(normalized, accountId)) ?? null;
+    }
+    return this.knownTargets.get(this.targetKey(normalized, this.defaultAccountId)) ?? Array.from(this.knownTargets.values()).find((target) => normalizeWhatsAppConnectorTarget(target.chatId) === normalized) ?? null;
+  }
+  findKnownChatByParticipant(participant, accountId) {
+    const normalized = normalizeWhatsAppConnectorTarget(participant);
+    const normalizedAccountId = accountId ? this.resolveAccountId(accountId) : null;
+    for (const target of this.knownTargets.values()) {
+      if (normalizedAccountId && target.accountId !== normalizedAccountId) {
+        continue;
+      }
+      if (normalizeWhatsAppConnectorTarget(target.senderId) === normalized || normalizeWhatsAppConnectorTarget(target.chatId) === normalized) {
+        return target;
+      }
     }
+    return null;
+  }
+  rememberTarget(target) {
+    this.knownTargets.set(this.targetKey(target.chatId, target.accountId), {
+      ...target,
+      accountId: this.resolveAccountId(target.accountId)
+    });
   }
-  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;
+
+// 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 normalizeE164(input) {
-  const stripped = input.replace(/[\s\-().]+/g, "");
-  const digitsOnly = stripped.replace(/[^\d+]/g, "");
-  if (!digitsOnly) {
-    return "";
+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 {}
   }
-  if (digitsOnly.startsWith("+")) {
-    return digitsOnly;
+  fs.rmSync(authDir, { recursive: true, force: true });
+}
+
+// src/webhook-auth.ts
+import crypto from "node:crypto";
+var SIGNATURE_HEADER = "x-hub-signature-256";
+function resolveWhatsAppAppSecret(runtime) {
+  const fromSetting = runtime.getSetting("WHATSAPP_APP_SECRET");
+  if (typeof fromSetting === "string" && fromSetting.trim()) {
+    return fromSetting.trim();
+  }
+  const fromEnv = process.env.WHATSAPP_APP_SECRET;
+  if (typeof fromEnv === "string" && fromEnv.trim()) {
+    return fromEnv.trim();
   }
-  if (digitsOnly.startsWith("00")) {
-    return `+${digitsOnly.slice(2)}`;
+  return null;
+}
+function verifyWhatsAppWebhookSignature(appSecret, signatureHeader, rawBody) {
+  if (!signatureHeader || !appSecret || !signatureHeader.startsWith("sha256=")) {
+    return false;
   }
-  if (digitsOnly.length >= 10) {
-    return `+${digitsOnly}`;
+  try {
+    const expectedSignature = signatureHeader.slice("sha256=".length);
+    const computedSignature = crypto.createHmac("sha256", appSecret).update(rawBody).digest("hex");
+    const expectedBuffer = Buffer.from(expectedSignature, "hex");
+    const computedBuffer = Buffer.from(computedSignature, "hex");
+    if (expectedBuffer.length !== computedBuffer.length) {
+      return false;
+    }
+    return crypto.timingSafeEqual(expectedBuffer, computedBuffer);
+  } catch {
+    return false;
   }
-  return digitsOnly;
 }
-function isWhatsAppGroupJid(value) {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  const lower = candidate.toLowerCase();
-  if (!lower.endsWith("@g.us")) {
+function readRouteHeader(req, name) {
+  const headers = req.headers;
+  if (!headers)
+    return;
+  const key = name.toLowerCase();
+  const value = headers[key] ?? headers[name] ?? headers[name.toUpperCase()];
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return typeof value === "string" ? value : undefined;
+}
+function readWebhookRawBody(req) {
+  if (typeof req.rawBody === "string" && req.rawBody.length > 0) {
+    return req.rawBody;
+  }
+  return null;
+}
+function isWhatsAppWebhookAuthorized(runtime, req) {
+  const rawBody = readWebhookRawBody(req);
+  if (rawBody === null) {
     return false;
   }
-  const localPart = candidate.slice(0, candidate.length - "@g.us".length);
-  if (!localPart || localPart.includes("@")) {
+  const appSecret = resolveWhatsAppAppSecret(runtime);
+  if (!appSecret) {
     return false;
   }
-  return /^[0-9]+(-[0-9]+)*$/.test(localPart);
+  return verifyWhatsAppWebhookSignature(appSecret, readRouteHeader(req, SIGNATURE_HEADER), rawBody);
 }
-function isWhatsAppUserTarget(value) {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  return WHATSAPP_USER_JID_RE.test(candidate) || WHATSAPP_LID_RE.test(candidate);
+
+// src/setup-routes.ts
+var whatsappPairingSessions = new Map;
+var MAX_PAIRING_SESSIONS = 10;
+function routeHost(req) {
+  const host = req.headers?.host;
+  return (Array.isArray(host) ? host[0] : host) ?? "localhost";
 }
-function extractUserJidPhone(jid) {
-  const userMatch = jid.match(WHATSAPP_USER_JID_RE);
-  if (userMatch) {
-    return userMatch[1];
+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);
+    }
   }
-  const lidMatch = jid.match(WHATSAPP_LID_RE);
-  if (lidMatch) {
-    return lidMatch[1];
+}
+async function handleWebhookVerify(req, res, runtime) {
+  const url = new URL(req.url ?? "/", `http://${routeHost(req)}`);
+  const mode = url.searchParams.get("hub.mode") ?? "";
+  const token = url.searchParams.get("hub.verify_token") ?? "";
+  const challenge = url.searchParams.get("hub.challenge") ?? "";
+  const accountId = url.searchParams.get("accountId") ?? undefined;
+  const service = runtime.getService("whatsapp");
+  if (!service || typeof service.verifyWebhook !== "function") {
+    res.status(503).json({ error: "WhatsApp service unavailable" });
+    return;
   }
-  return null;
+  const verifiedChallenge = service.verifyWebhook(mode, token, challenge, accountId);
+  if (!verifiedChallenge) {
+    res.status(403).json({ error: "Webhook verification failed" });
+    return;
+  }
+  res.status(200).json(verifiedChallenge);
 }
-function normalizeWhatsAppTarget(value) {
-  const candidate = stripWhatsAppTargetPrefixes(value);
-  if (!candidate) {
-    return null;
+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;
   }
-  if (isWhatsAppGroupJid(candidate)) {
-    const localPart = candidate.slice(0, candidate.length - "@g.us".length);
-    return `${localPart}@g.us`;
+  if (!isWhatsAppWebhookAuthorized(runtime, req)) {
+    res.status(401).json({ error: "Unauthorized" });
+    return;
   }
-  if (isWhatsAppUserTarget(candidate)) {
-    const phone = extractUserJidPhone(candidate);
-    if (!phone) {
-      return null;
-    }
-    const normalized2 = normalizeE164(phone);
-    return normalized2.length > 1 ? normalized2 : null;
+  const rawBody = readWebhookRawBody(req);
+  if (!rawBody) {
+    res.status(400).json({ error: "Missing request body" });
+    return;
   }
-  if (candidate.includes("@")) {
-    return null;
+  let body;
+  try {
+    const parsed = JSON.parse(rawBody);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      res.status(400).json({ error: "Invalid request body" });
+      return;
+    }
+    body = parsed;
+  } catch {
+    res.status(400).json({ error: "Invalid request body" });
+    return;
   }
-  const normalized = normalizeE164(candidate);
-  return normalized.length > 1 ? normalized : null;
+  await service.handleWebhook(body);
+  res.status(200).json("EVENT_RECEIVED");
 }
-function formatWhatsAppId(id) {
-  if (isWhatsAppGroupJid(id)) {
-    return `group:${id}`;
+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;
+            const previousConfig = connectors.whatsapp;
+            if (accountId === "default") {
+              connectors.whatsapp = {
+                ...previousConfig,
+                authDir,
+                transport: "baileys",
+                enabled: true
+              };
+              return;
+            }
+            const accounts = typeof previousConfig.accounts === "object" && previousConfig.accounts !== null ? { ...previousConfig.accounts } : {};
+            accounts[accountId] = {
+              ...accounts[accountId] ?? {},
+              authDir,
+              transport: "baileys",
+              enabled: true
+            };
+            connectors.whatsapp = {
+              ...previousConfig,
+              accounts,
+              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) });
   }
-  const normalized = normalizeWhatsAppTarget(id);
-  return normalized || id;
-}
-function isWhatsAppGroup(id) {
-  return isWhatsAppGroupJid(id);
 }
-function getWhatsAppChatType(id) {
-  return isWhatsAppGroupJid(id) ? "group" : "user";
+async function handleStatus(req, res, runtime) {
+  cleanupStaleSessions();
+  const setupService = getSetupService(runtime);
+  const url = new URL(req.url ?? "/", `http://${routeHost(req)}`);
+  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
+  });
 }
-function buildWhatsAppUserJid(phoneNumber) {
-  const normalized = normalizeE164(phoneNumber);
-  const digits = normalized.replace(/^\+/, "");
-  return `${digits}@s.whatsapp.net`;
+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" });
 }
-function splitAtBreakPoint(text, limit) {
-  if (text.length <= limit) {
-    return { chunk: text, remainder: "" };
+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 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 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) {
+        if (accountId === "default") {
+          delete connectors.whatsapp;
+          return;
+        }
+        const whatsappConfig = connectors.whatsapp;
+        const accounts = whatsappConfig?.accounts;
+        if (accounts) {
+          delete accounts[accountId];
+        }
+        connectors.whatsapp = {
+          ...whatsappConfig ?? {},
+          ...accounts ? { accounts } : {}
+        };
+      }
+    });
   }
-  const singleNewline = searchArea.lastIndexOf(`
-`);
-  if (singleNewline > limit * 0.5) {
-    return {
-      chunk: text.slice(0, singleNewline).trimEnd(),
-      remainder: text.slice(singleNewline + 1).trimStart()
-    };
+  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 {}
   }
-  const sentenceEnd = Math.max(searchArea.lastIndexOf(". "), searchArea.lastIndexOf("! "), searchArea.lastIndexOf("? "));
-  if (sentenceEnd > limit * 0.5) {
+  whatsappPairingSessions.clear();
+}
+
+// src/workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["whatsAppApi"];
+
+class WhatsAppWorkflowCredentialProvider extends Service2 {
+  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
+  capabilityDescription = "Supplies WhatsApp credentials to the workflow plugin.";
+  static async start(runtime) {
+    return new WhatsAppWorkflowCredentialProvider(runtime);
+  }
+  async stop() {}
+  async resolve(_userId, credType) {
+    if (credType !== "whatsAppApi")
+      return null;
+    const accessToken = this.runtime.getSetting("WHATSAPP_ACCESS_TOKEN");
+    const phoneNumberId = this.runtime.getSetting("WHATSAPP_PHONE_NUMBER_ID");
+    if (!accessToken?.trim() || !phoneNumberId?.trim())
+      return null;
     return {
-      chunk: text.slice(0, sentenceEnd + 1).trimEnd(),
-      remainder: text.slice(sentenceEnd + 2).trimStart()
+      status: "credential_data",
+      data: { accessToken: accessToken.trim(), phoneNumberId: phoneNumberId.trim() }
     };
   }
-  const space = searchArea.lastIndexOf(" ");
-  if (space > limit * 0.5) {
+  checkCredentialTypes(credTypes) {
     return {
-      chunk: text.slice(0, space).trimEnd(),
-      remainder: text.slice(space + 1).trimStart()
+      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
+      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
     };
   }
-  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 [];
+// src/api/whatsapp-routes.ts
+import fs3 from "node:fs";
+import path3 from "node:path";
+import { logger } from "@elizaos/core";
+var MAX_BODY_BYTES = 1048576;
+var MAX_PAIRING_SESSIONS2 = 10;
+async function readJsonBody(req, res) {
+  let bytes = 0;
+  let body = "";
+  try {
+    for await (const chunk of req) {
+      const text = typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf8");
+      bytes += Buffer.byteLength(text);
+      if (bytes > MAX_BODY_BYTES) {
+        json(res, { error: "Request body too large" }, 413);
+        return null;
+      }
+      body += text;
+    }
+  } catch (err) {
+    logger.warn({ err }, "Failed to read WhatsApp request body");
+    json(res, { error: "Failed to read request body" }, 400);
+    return null;
   }
-  const normalizedText = text.trim();
-  if (normalizedText.length <= limit) {
-    return [normalizedText];
+  if (!body.trim()) {
+    return {};
   }
-  const chunks = [];
-  let remaining = normalizedText;
-  while (remaining.length > 0) {
-    const { chunk, remainder } = splitAtBreakPoint(remaining, limit);
-    if (chunk) {
-      chunks.push(chunk);
-    }
-    remaining = remainder;
+  try {
+    return JSON.parse(body);
+  } catch {
+    json(res, { error: "Invalid JSON body" }, 400);
+    return null;
   }
-  return chunks.filter((c) => c.length > 0);
 }
-function truncateText(text, maxLength) {
-  if (text.length <= maxLength) {
-    return text;
+function json(res, data, status = 200) {
+  if (!res.headersSent) {
+    res.statusCode = status;
+    res.setHeader("Content-Type", "application/json");
   }
-  if (maxLength <= 3) {
-    return "...".slice(0, maxLength);
+  res.end(JSON.stringify(data));
+}
+function setOwnerContact(config, update) {
+  if (!update.source)
+    return false;
+  if (!config.agents)
+    config.agents = {};
+  if (!config.agents.defaults)
+    config.agents.defaults = {};
+  if (!config.agents.defaults.ownerContacts)
+    config.agents.defaults.ownerContacts = {};
+  const existing = config.agents.defaults.ownerContacts[update.source];
+  const entry = {};
+  if (update.channelId)
+    entry.channelId = update.channelId;
+  if (update.entityId)
+    entry.entityId = update.entityId;
+  if (update.roomId)
+    entry.roomId = update.roomId;
+  if (Object.keys(entry).length === 0)
+    return false;
+  if (existing && existing.channelId === entry.channelId && existing.entityId === entry.entityId && existing.roomId === entry.roomId) {
+    return false;
   }
-  return `${text.slice(0, maxLength - 3)}...`;
+  config.agents.defaults.ownerContacts[update.source] = entry;
+  return true;
 }
-function resolveWhatsAppSystemLocation(params) {
-  const { chatType, chatId, chatName } = params;
-  const name = chatName || chatId.slice(0, 8);
-  return `WhatsApp ${chatType}:${name}`;
+function shouldConfigurePlugin(body) {
+  return body?.configurePlugin !== false;
 }
-function isValidWhatsAppNumber(value) {
-  const normalized = normalizeWhatsAppTarget(value);
-  if (!normalized) {
-    return false;
+function resolveAuthScope(value) {
+  return value === "lifeops" ? "lifeops" : "platform";
+}
+function resolveSessionKey(authScope, accountId) {
+  return `${authScope}:${accountId}`;
+}
+function resolveAuthDir(workspaceDir, accountId, authScope) {
+  return path3.join(workspaceDir, authScope === "lifeops" ? "lifeops-whatsapp-auth" : "whatsapp-auth", accountId);
+}
+function authExistsForScope(state, deps, accountId, authScope) {
+  if (authScope === "platform") {
+    return deps.whatsappAuthExists(state.workspaceDir, accountId);
   }
-  if (!normalized.startsWith("+")) {
+  return fs3.existsSync(path3.join(resolveAuthDir(state.workspaceDir, accountId, authScope), "creds.json"));
+}
+async function handleWhatsAppRoute(req, res, pathname, method, state, deps) {
+  if (!pathname.startsWith("/api/whatsapp"))
     return false;
+  if (pathname === "/api/whatsapp/webhook" && method === "GET") {
+    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 = state.runtime?.getService("whatsapp");
+    if (!service || typeof service.verifyWebhook !== "function") {
+      json(res, { error: "WhatsApp service unavailable" }, 503);
+      return true;
+    }
+    const verifiedChallenge = service.verifyWebhook(mode, token, challenge);
+    if (!verifiedChallenge) {
+      json(res, { error: "Webhook verification failed" }, 403);
+      return true;
+    }
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/plain");
+    res.end(verifiedChallenge);
+    return true;
   }
-  const digits = normalized.replace(/^\+/, "");
-  return /^\d{10,15}$/.test(digits);
+  if (pathname === "/api/whatsapp/webhook" && method === "POST") {
+    const service = state.runtime?.getService("whatsapp");
+    if (!service || typeof service.handleWebhook !== "function") {
+      json(res, { error: "WhatsApp service unavailable" }, 503);
+      return true;
+    }
+    const body = await readJsonBody(req, res);
+    if (!body) {
+      return true;
+    }
+    await service.handleWebhook(body);
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "text/plain");
+    res.end("EVENT_RECEIVED");
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/whatsapp/pair") {
+    const body = await readJsonBody(req, res);
+    const authScope = resolveAuthScope(body?.authScope);
+    const configurePlugin = authScope === "platform" && shouldConfigurePlugin(body);
+    let accountId;
+    try {
+      accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+    } catch (err) {
+      json(res, { error: err.message }, 400);
+      return true;
+    }
+    const sessionKey = resolveSessionKey(authScope, accountId);
+    const isReplacing = state.whatsappPairingSessions.has(sessionKey);
+    if (!isReplacing && state.whatsappPairingSessions.size >= MAX_PAIRING_SESSIONS2) {
+      json(res, {
+        error: `Too many concurrent pairing sessions (max ${MAX_PAIRING_SESSIONS2})`
+      }, 429);
+      return true;
+    }
+    const authDir = resolveAuthDir(state.workspaceDir, accountId, authScope);
+    state.whatsappPairingSessions.get(sessionKey)?.stop();
+    const session = deps.createWhatsAppPairingSession({
+      authDir,
+      accountId,
+      onEvent: (event) => {
+        state.broadcastWs?.({ ...event, authScope });
+        if (event.status === "connected") {
+          let configChanged = false;
+          if (configurePlugin) {
+            if (!state.config.connectors)
+              state.config.connectors = {};
+            state.config.connectors.whatsapp = {
+              ...state.config.connectors.whatsapp ?? {},
+              authDir,
+              enabled: true
+            };
+            configChanged = true;
+          }
+          const phoneNumber = event.phoneNumber;
+          configChanged = setOwnerContact(state.config, {
+            source: "whatsapp",
+            channelId: phoneNumber ?? undefined
+          }) || configChanged;
+          if (!configChanged) {
+            return;
+          }
+          try {
+            state.saveConfig();
+          } catch {}
+        }
+      }
+    });
+    state.whatsappPairingSessions.set(sessionKey, session);
+    try {
+      await session.start();
+      json(res, {
+        ok: true,
+        accountId,
+        authScope,
+        status: session.getStatus()
+      });
+    } catch (err) {
+      json(res, { ok: false, error: String(err) }, 500);
+    }
+    return true;
+  }
+  if (method === "GET" && pathname === "/api/whatsapp/status") {
+    const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+    let accountId;
+    try {
+      accountId = deps.sanitizeAccountId(url.searchParams.get("accountId") || "default");
+    } catch (err) {
+      json(res, { error: err.message }, 400);
+      return true;
+    }
+    const authScope = resolveAuthScope(url.searchParams.get("authScope"));
+    const sessionKey = resolveSessionKey(authScope, accountId);
+    const session = state.whatsappPairingSessions.get(sessionKey);
+    let serviceConnected = false;
+    let servicePhone = null;
+    if (state.runtime) {
+      try {
+        const waService = state.runtime.getService("whatsapp");
+        if (waService) {
+          serviceConnected = Boolean(waService.connected);
+          servicePhone = waService.phoneNumber ?? null;
+        }
+      } catch {}
+    }
+    json(res, {
+      accountId,
+      authScope,
+      status: session?.getStatus() ?? "idle",
+      authExists: authExistsForScope(state, deps, accountId, authScope),
+      serviceConnected,
+      servicePhone
+    });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/whatsapp/pair/stop") {
+    const body = await readJsonBody(req, res);
+    const authScope = resolveAuthScope(body?.authScope);
+    let accountId;
+    try {
+      accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+    } catch (err) {
+      json(res, { error: err.message }, 400);
+      return true;
+    }
+    const sessionKey = resolveSessionKey(authScope, accountId);
+    const session = state.whatsappPairingSessions.get(sessionKey);
+    if (session) {
+      session.stop();
+      state.whatsappPairingSessions.delete(sessionKey);
+    }
+    json(res, { ok: true, accountId, authScope, status: "idle" });
+    return true;
+  }
+  if (method === "POST" && pathname === "/api/whatsapp/disconnect") {
+    const body = await readJsonBody(req, res);
+    const authScope = resolveAuthScope(body?.authScope);
+    const configurePlugin = authScope === "platform" && shouldConfigurePlugin(body);
+    let accountId;
+    try {
+      accountId = deps.sanitizeAccountId(body && typeof body.accountId === "string" && body.accountId.trim() ? body.accountId.trim() : "default");
+    } catch (err) {
+      json(res, { error: err.message }, 400);
+      return true;
+    }
+    const sessionKey = resolveSessionKey(authScope, accountId);
+    const session = state.whatsappPairingSessions.get(sessionKey);
+    if (session) {
+      session.stop();
+      state.whatsappPairingSessions.delete(sessionKey);
+    }
+    const authDir = resolveAuthDir(state.workspaceDir, accountId, authScope);
+    try {
+      if (authScope === "platform") {
+        await deps.whatsappLogout(state.workspaceDir, accountId);
+      } else {
+        fs3.rmSync(authDir, { recursive: true, force: true });
+      }
+    } catch (logoutErr) {
+      logger.warn({
+        accountId,
+        error: logoutErr instanceof Error ? logoutErr.message : String(logoutErr)
+      }, "[whatsapp] Logout failed, deleting auth files directly");
+      try {
+        fs3.rmSync(authDir, { recursive: true, force: true });
+      } catch {}
+    }
+    if (configurePlugin && state.config.connectors) {
+      delete state.config.connectors.whatsapp;
+      try {
+        state.saveConfig();
+      } catch {}
+    }
+    json(res, { ok: true, accountId, authScope });
+    return true;
+  }
+  return false;
 }
-function formatWhatsAppPhoneNumber(phoneNumber) {
-  const normalized = normalizeE164(phoneNumber);
-  if (!normalized) {
-    return phoneNumber;
+function applyWhatsAppQrOverride(plugins, workspaceDir) {
+  try {
+    const waCredsPath = path3.join(workspaceDir, "whatsapp-auth", "default", "creds.json");
+    if (fs3.existsSync(waCredsPath)) {
+      const waPlugin = plugins.find((plugin) => plugin.id === "whatsapp");
+      if (waPlugin) {
+        waPlugin.validationErrors = [];
+        waPlugin.configured = true;
+        waPlugin.qrConnected = true;
+      }
+    }
+  } catch {}
+}
+// 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".`);
   }
-  const digits = normalized.replace(/^\+/, "");
-  if (digits.length <= 10) {
-    return normalized;
+  if ("authDir" in config && config.authDir) {
+    return "baileys";
   }
-  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)}`;
+  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) => {
@@ -1522,61 +3166,83 @@ var WHATSAPP_REACTIONS = {
   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]
+  actions: [],
+  services: [WhatsAppConnectorService, WhatsAppWorkflowCredentialProvider],
+  routes: whatsappSetupRoutes,
+  autoEnable: {
+    connectorKeys: ["whatsapp"]
+  },
+  init: async (_config, runtime) => {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createWhatsAppConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger2.warn({
+        src: "plugin:whatsapp",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register WhatsApp provider with ConnectorAccountManager");
+    }
+  },
+  async dispose(runtime) {
+    const svc = runtime.getService(WhatsAppConnectorService.serviceType);
+    await svc?.stop();
+  }
 };
 var src_default = whatsappPlugin;
+var __bundle_safety_PLUGINS_PLUGIN_WHATSAPP_SRC_INDEX__ = [
+  checkWhatsAppUserAccess,
+  DEFAULT_ACCOUNT_ID,
+  isMultiAccountEnabled,
+  isWhatsAppMentionRequired,
+  isWhatsAppUserAllowed,
+  listEnabledWhatsAppAccounts,
+  listWhatsAppAccountIds,
+  normalizeAccountId,
+  resolveDefaultWhatsAppAccountId,
+  resolveWhatsAppAccount,
+  resolveWhatsAppGroupConfig,
+  resolveWhatsAppToken,
+  applyWhatsAppQrOverride,
+  handleWhatsAppRoute,
+  MAX_PAIRING_SESSIONS2,
+  ClientFactory,
+  createWhatsAppConnectorAccountProvider,
+  WHATSAPP_PROVIDER_ID,
+  buildWhatsAppUserJid,
+  chunkWhatsAppText,
+  formatWhatsAppId,
+  formatWhatsAppPhoneNumber,
+  getWhatsAppChatType,
+  isValidWhatsAppNumber,
+  isWhatsAppGroup,
+  isWhatsAppGroupJid,
+  isWhatsAppUserTarget,
+  normalizeE164,
+  normalizeWhatsAppTarget,
+  resolveWhatsAppSystemLocation,
+  truncateText,
+  WHATSAPP_TEXT_CHUNK_LIMIT,
+  sanitizeAccountId,
+  WhatsAppPairingSession,
+  whatsappAuthExists,
+  whatsappLogout,
+  WhatsAppConnectorService,
+  stopAllPairingSessions,
+  whatsappSetupRoutes
+];
+var bundleSafetyGlobal = globalThis;
+bundleSafetyGlobal.__bundle_safety_PLUGINS_PLUGIN_WHATSAPP_SRC_INDEX__ = __bundle_safety_PLUGINS_PLUGIN_WHATSAPP_SRC_INDEX__;
 export {
+  whatsappSetupRoutes,
+  whatsappLogout,
+  whatsappAuthExists,
   truncateText,
+  stopAllPairingSessions,
+  sanitizeAccountId as sanitizeWhatsAppAccountId,
   resolveWhatsAppToken,
   resolveWhatsAppSystemLocation,
   resolveWhatsAppGroupConfig,
@@ -1594,20 +3260,26 @@ export {
   isWhatsAppGroup,
   isValidWhatsAppNumber,
   isMultiAccountEnabled,
+  handleWhatsAppRoute,
   getWhatsAppChatType,
   formatWhatsAppPhoneNumber,
   formatWhatsAppId,
   src_default as default,
+  createWhatsAppConnectorAccountProvider,
   chunkWhatsAppText,
   checkWhatsAppUserAccess,
   buildWhatsAppUserJid,
-  WhatsAppPlugin,
+  applyWhatsAppQrOverride,
+  WhatsAppPairingSession,
   WhatsAppEventType,
+  WhatsAppConnectorService,
   WHATSAPP_TEXT_CHUNK_LIMIT,
   WHATSAPP_REACTIONS,
+  WHATSAPP_PROVIDER_ID,
+  MAX_PAIRING_SESSIONS2 as WHATSAPP_MAX_PAIRING_SESSIONS,
   DEFAULT_ACCOUNT_ID,
   ClientFactory
 };
 
-//# debugId=2FB406236C995FEF64756E2164756E21
+//# debugId=8DCA091A96E61C8E64756E2164756E21
 //# sourceMappingURL=index.js.map