@openclaw/whatsapp 2026.5.2-beta.2 → 2026.5.3-beta.1

package/dist/access-control-BQ3tCkH8.js

@@ -0,0 +1,288 @@
+import { a as resolveWhatsAppAccount } from "./accounts-BDqgpFEB.js";
+import { r as isSelfChatMode, t as text_runtime_exports } from "./text-runtime-C1zNiZeO.js";
+import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-QHAlV7Fu.js";
+import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-Gp1lQ0at.js";
+import { defaultRuntime } from "openclaw/plugin-sdk/runtime-env";
+import { resolveChannelGroupPolicy, resolveChannelGroupRequireMention } from "openclaw/plugin-sdk/channel-policy";
+import { createChannelPairingChallengeIssuer } from "openclaw/plugin-sdk/channel-pairing";
+import { upsertChannelPairingRequest } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import { expandAllowFromWithAccessGroups, readStoreAllowFromForDmPolicy, resolveDmGroupAccessWithCommandGate, resolveDmGroupAccessWithLists, resolveEffectiveAllowFromLists } from "openclaw/plugin-sdk/security-runtime";
+import { resolveGroupSessionKey } from "openclaw/plugin-sdk/session-store-runtime";
+//#region extensions/whatsapp/src/inbound-policy.ts
+function resolveGroupConversationId(conversationId) {
+	return resolveGroupSessionKey({
+		From: conversationId,
+		ChatType: "group",
+		Provider: "whatsapp"
+	})?.id ?? conversationId;
+}
+function isNormalizedSenderAllowed(allowEntries, sender) {
+	if (allowEntries.includes("*")) return true;
+	const normalizedSender = (0, text_runtime_exports.normalizeE164)(sender ?? "");
+	if (!normalizedSender) return false;
+	return new Set(allowEntries.map((entry) => (0, text_runtime_exports.normalizeE164)(entry)).filter((entry) => Boolean(entry))).has(normalizedSender);
+}
+function buildResolvedWhatsAppGroupConfig(params) {
+	return { channels: { whatsapp: {
+		groupPolicy: params.groupPolicy,
+		groups: params.groups
+	} } };
+}
+function resolveWhatsAppInboundPolicy(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const configuredAllowFrom = account.allowFrom ?? [];
+	const dmPolicy = account.dmPolicy ?? "pairing";
+	const dmAllowFrom = configuredAllowFrom.length > 0 ? configuredAllowFrom : params.selfE164 ? [params.selfE164] : [];
+	const groupAllowFrom = account.groupAllowFrom ?? (configuredAllowFrom.length > 0 ? configuredAllowFrom : void 0) ?? [];
+	const { effectiveGroupAllowFrom } = resolveEffectiveAllowFromLists({
+		allowFrom: configuredAllowFrom,
+		groupAllowFrom
+	});
+	const defaultGroupPolicy = resolveDefaultGroupPolicy(params.cfg);
+	const { groupPolicy, providerMissingFallbackApplied } = resolveWhatsAppRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.whatsapp !== void 0,
+		groupPolicy: account.groupPolicy,
+		defaultGroupPolicy
+	});
+	const resolvedGroupCfg = buildResolvedWhatsAppGroupConfig({
+		groupPolicy,
+		groups: account.groups
+	});
+	const isSamePhone = (value) => typeof value === "string" && typeof params.selfE164 === "string" && value === params.selfE164;
+	return {
+		account,
+		dmPolicy,
+		groupPolicy,
+		configuredAllowFrom,
+		dmAllowFrom,
+		groupAllowFrom,
+		isSelfChat: account.selfChatMode ?? isSelfChatMode(params.selfE164, configuredAllowFrom),
+		providerMissingFallbackApplied,
+		shouldReadStorePairingApprovals: dmPolicy !== "allowlist",
+		isSamePhone,
+		isDmSenderAllowed: (allowEntries, sender) => isSamePhone(sender) || isNormalizedSenderAllowed(allowEntries, sender),
+		isGroupSenderAllowed: (allowEntries, sender) => isNormalizedSenderAllowed(allowEntries, sender),
+		resolveConversationGroupPolicy: (conversationId) => resolveChannelGroupPolicy({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveGroupConversationId(conversationId),
+			hasGroupAllowFrom: effectiveGroupAllowFrom.length > 0
+		}),
+		resolveConversationRequireMention: (conversationId) => resolveChannelGroupRequireMention({
+			cfg: resolvedGroupCfg,
+			channel: "whatsapp",
+			groupId: resolveGroupConversationId(conversationId)
+		})
+	};
+}
+async function resolveWhatsAppCommandAuthorized(params) {
+	const useAccessGroups = params.cfg.commands?.useAccessGroups !== false;
+	if (!useAccessGroups) return true;
+	const self = getSelfIdentity(params.msg);
+	const policy = params.policy ?? resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.msg.accountId,
+		selfE164: self.e164 ?? null
+	});
+	const isGroup = params.msg.chatType === "group";
+	const sender = getSenderIdentity(params.msg);
+	const dmSender = sender.e164 ?? params.msg.from ?? "";
+	const groupSender = sender.e164 ?? "";
+	const normalizedSender = (0, text_runtime_exports.normalizeE164)(isGroup ? groupSender : dmSender);
+	if (!normalizedSender) return false;
+	const storeAllowFrom = isGroup || !policy.shouldReadStorePairingApprovals ? [] : await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: policy.account.accountId,
+		dmPolicy: policy.dmPolicy,
+		shouldRead: policy.shouldReadStorePairingApprovals
+	});
+	const isSenderAllowed = (senderId, allowEntries) => isGroup ? policy.isGroupSenderAllowed(allowEntries, senderId) : policy.isDmSenderAllowed(allowEntries, senderId);
+	const [allowFrom, groupAllowFrom] = await Promise.all([expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.dmAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	}), expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.groupAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	})]);
+	const dmStoreAllowFrom = isGroup ? [] : await expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: storeAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: normalizedSender,
+		isSenderAllowed
+	});
+	return resolveDmGroupAccessWithCommandGate({
+		isGroup,
+		dmPolicy: policy.dmPolicy,
+		groupPolicy: policy.groupPolicy,
+		allowFrom,
+		groupAllowFrom,
+		storeAllowFrom: dmStoreAllowFrom,
+		isSenderAllowed: (allowEntries) => isGroup ? policy.isGroupSenderAllowed(allowEntries, groupSender) : policy.isDmSenderAllowed(allowEntries, dmSender),
+		command: {
+			useAccessGroups,
+			allowTextCommands: true,
+			hasControlCommand: true
+		}
+	}).commandAuthorized;
+}
+//#endregion
+//#region extensions/whatsapp/src/inbound/access-control.ts
+const PAIRING_REPLY_HISTORY_GRACE_MS = 3e4;
+function logWhatsAppVerbose(enabled, message) {
+	if (!enabled) return;
+	defaultRuntime.log(message);
+}
+async function checkInboundAccessControl(params) {
+	const policy = resolveWhatsAppInboundPolicy({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		selfE164: params.selfE164
+	});
+	const storeAllowFrom = params.group ? [] : await readStoreAllowFromForDmPolicy({
+		provider: "whatsapp",
+		accountId: policy.account.accountId,
+		dmPolicy: policy.dmPolicy,
+		shouldRead: policy.shouldReadStorePairingApprovals
+	});
+	const pairingGraceMs = typeof params.pairingGraceMs === "number" && params.pairingGraceMs > 0 ? params.pairingGraceMs : PAIRING_REPLY_HISTORY_GRACE_MS;
+	const suppressPairingReply = typeof params.connectedAtMs === "number" && typeof params.messageTimestampMs === "number" && params.messageTimestampMs < params.connectedAtMs - pairingGraceMs;
+	warnMissingProviderGroupPolicyFallbackOnce({
+		providerMissingFallbackApplied: policy.providerMissingFallbackApplied,
+		providerKey: "whatsapp",
+		accountId: policy.account.accountId,
+		log: (message) => logWhatsAppVerbose(params.verbose, message)
+	});
+	const accessGroupSenderId = params.group ? params.senderE164 ?? params.from : params.from;
+	const isAccessGroupSenderAllowed = (senderId, allowEntries) => {
+		return params.group ? policy.isGroupSenderAllowed(allowEntries, senderId) : policy.isDmSenderAllowed(allowEntries, senderId);
+	};
+	const [allowFrom, groupAllowFrom] = await Promise.all([expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: params.group ? policy.configuredAllowFrom : policy.dmAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	}), expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: policy.groupAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	})]);
+	const dmStoreAllowFrom = params.group ? [] : await expandAllowFromWithAccessGroups({
+		cfg: params.cfg,
+		allowFrom: storeAllowFrom,
+		channel: "whatsapp",
+		accountId: policy.account.accountId,
+		senderId: accessGroupSenderId,
+		isSenderAllowed: isAccessGroupSenderAllowed
+	});
+	const access = resolveDmGroupAccessWithLists({
+		isGroup: params.group,
+		dmPolicy: policy.dmPolicy,
+		groupPolicy: policy.groupPolicy,
+		allowFrom,
+		groupAllowFrom,
+		storeAllowFrom: dmStoreAllowFrom,
+		isSenderAllowed: (allowEntries) => {
+			return params.group ? policy.isGroupSenderAllowed(allowEntries, params.senderE164) : policy.isDmSenderAllowed(allowEntries, params.from);
+		}
+	});
+	if (params.group && access.decision !== "allow") {
+		if (access.reason === "groupPolicy=disabled") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: disabled)");
+		else if (access.reason === "groupPolicy=allowlist (empty allowlist)") logWhatsAppVerbose(params.verbose, "Blocked group message (groupPolicy: allowlist, no groupAllowFrom)");
+		else logWhatsAppVerbose(params.verbose, `Blocked group message from ${params.senderE164 ?? "unknown sender"} (groupPolicy: allowlist)`);
+		return {
+			allowed: false,
+			shouldMarkRead: false,
+			isSelfChat: policy.isSelfChat,
+			resolvedAccountId: policy.account.accountId
+		};
+	}
+	if (!params.group) {
+		if (params.isFromMe && !policy.isSamePhone(params.from)) {
+			logWhatsAppVerbose(params.verbose, "Skipping outbound DM (fromMe); no pairing reply needed.");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision === "block" && access.reason === "dmPolicy=disabled") {
+			logWhatsAppVerbose(params.verbose, "Blocked dm (dmPolicy: disabled)");
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision === "pairing" && !policy.isSamePhone(params.from)) {
+			const candidate = params.from;
+			if (suppressPairingReply) logWhatsAppVerbose(params.verbose, `Skipping pairing reply for historical DM from ${candidate}.`);
+			else await createChannelPairingChallengeIssuer({
+				channel: "whatsapp",
+				upsertPairingRequest: async ({ id, meta }) => await upsertChannelPairingRequest({
+					channel: "whatsapp",
+					id,
+					accountId: policy.account.accountId,
+					meta
+				})
+			})({
+				senderId: candidate,
+				senderIdLine: `Your WhatsApp phone number: ${candidate}`,
+				meta: { name: (params.pushName ?? "").trim() || void 0 },
+				onCreated: () => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing request sender=${candidate} name=${params.pushName ?? "unknown"}`);
+				},
+				sendPairingReply: async (text) => {
+					await params.sock.sendMessage(params.remoteJid, { text });
+				},
+				onReplyError: (err) => {
+					logWhatsAppVerbose(params.verbose, `whatsapp pairing reply failed for ${candidate}: ${String(err)}`);
+				}
+			});
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+		if (access.decision !== "allow") {
+			logWhatsAppVerbose(params.verbose, `Blocked unauthorized sender ${params.from} (dmPolicy=${policy.dmPolicy})`);
+			return {
+				allowed: false,
+				shouldMarkRead: false,
+				isSelfChat: policy.isSelfChat,
+				resolvedAccountId: policy.account.accountId
+			};
+		}
+	}
+	return {
+		allowed: true,
+		shouldMarkRead: true,
+		isSelfChat: policy.isSelfChat,
+		resolvedAccountId: policy.account.accountId
+	};
+}
+const __testing = { resolveWhatsAppInboundPolicy };
+//#endregion
+export { resolveWhatsAppInboundPolicy as i, checkInboundAccessControl as n, resolveWhatsAppCommandAuthorized as r, __testing as t };

package/dist/account-config-CNQ33oav.js

@@ -0,0 +1,47 @@
+import { DEFAULT_ACCOUNT_ID, mergeAccountConfig, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
+import { resolveChannelStreamingBlockEnabled, resolveChannelStreamingChunkMode } from "openclaw/plugin-sdk/channel-streaming";
+//#region extensions/whatsapp/src/account-config.ts
+function resolveWhatsAppDefaultAccountSharedConfig(cfg) {
+	const defaultAccount = resolveAccountEntry(cfg.channels?.whatsapp?.accounts, DEFAULT_ACCOUNT_ID);
+	if (!defaultAccount) return;
+	const { enabled: _ignoredEnabled, name: _ignoredName, authDir: _ignoredAuthDir, selfChatMode: _ignoredSelfChatMode, ...sharedDefaults } = defaultAccount;
+	return sharedDefaults;
+}
+function _resolveWhatsAppAccountConfig(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.whatsapp?.accounts, accountId);
+}
+function resolveMergedNamedWhatsAppAccountConfig(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountConfig = _resolveWhatsAppAccountConfig(params.cfg, params.accountId);
+	return {
+		...mergeAccountConfig({
+			channelConfig: rootCfg,
+			accountConfig: void 0,
+			omitKeys: ["defaultAccount"]
+		}),
+		...resolveWhatsAppDefaultAccountSharedConfig(params.cfg),
+		...accountConfig
+	};
+}
+function resolveMergedWhatsAppAccountConfig(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountId = params.accountId?.trim() || rootCfg?.defaultAccount || DEFAULT_ACCOUNT_ID;
+	const base = resolveMergedAccountConfig({
+		channelConfig: rootCfg,
+		accounts: rootCfg?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"]
+	});
+	const merged = accountId === DEFAULT_ACCOUNT_ID ? base : resolveMergedNamedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		...merged,
+		chunkMode: resolveChannelStreamingChunkMode(merged) ?? merged.chunkMode,
+		blockStreaming: resolveChannelStreamingBlockEnabled(merged) ?? merged.blockStreaming
+	};
+}
+//#endregion
+export { resolveMergedWhatsAppAccountConfig as t };

package/dist/account-ids-DG18xddX.js

@@ -0,0 +1,5 @@
+import { createAccountListHelpers } from "openclaw/plugin-sdk/account-core";
+//#region extensions/whatsapp/src/account-ids.ts
+const { listConfiguredAccountIds, listAccountIds, resolveDefaultAccountId: resolveDefaultWhatsAppAccountId } = createAccountListHelpers("whatsapp");
+//#endregion
+export { listConfiguredAccountIds as n, resolveDefaultWhatsAppAccountId as r, listAccountIds as t };

package/dist/accounts-BDqgpFEB.js

@@ -0,0 +1,116 @@
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-CNQ33oav.js";
+import { n as listConfiguredAccountIds, r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-DG18xddX.js";
+import { t as hasWebCredsSync } from "./creds-files-_2V8jzQa.js";
+import fs from "node:fs";
+import path from "node:path";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveUserPath } from "openclaw/plugin-sdk/account-core";
+import { resolveOAuthDir } from "openclaw/plugin-sdk/state-paths";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/whatsapp/src/accounts.ts
+const DEFAULT_WHATSAPP_MEDIA_MAX_MB = 50;
+function listWhatsAppAuthDirs(cfg) {
+	const oauthDir = resolveOAuthDir();
+	const whatsappDir = path.join(oauthDir, "whatsapp");
+	const authDirs = new Set([oauthDir, path.join(whatsappDir, DEFAULT_ACCOUNT_ID)]);
+	const accountIds = listConfiguredAccountIds(cfg);
+	for (const accountId of accountIds) authDirs.add(resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	}).authDir);
+	try {
+		const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			authDirs.add(path.join(whatsappDir, entry.name));
+		}
+	} catch {}
+	return Array.from(authDirs);
+}
+function hasAnyWhatsAppAuth(cfg) {
+	return listWhatsAppAuthDirs(cfg).some((authDir) => hasWebCredsSync(authDir));
+}
+function resolveDefaultAuthDir(accountId) {
+	return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+function resolveLegacyAuthDir() {
+	return resolveOAuthDir();
+}
+function legacyAuthExists(authDir) {
+	try {
+		return fs.existsSync(path.join(authDir, "creds.json"));
+	} catch {
+		return false;
+	}
+}
+function resolveWhatsAppAuthDir(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const configured = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId
+	})?.authDir?.trim();
+	if (configured) return {
+		authDir: resolveUserPath(configured),
+		isLegacy: false
+	};
+	const defaultDir = resolveDefaultAuthDir(accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const legacyDir = resolveLegacyAuthDir();
+		if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) return {
+			authDir: legacyDir,
+			isLegacy: true
+		};
+	}
+	return {
+		authDir: defaultDir,
+		isLegacy: false
+	};
+}
+function resolveWhatsAppAccount(params) {
+	const merged = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg)
+	});
+	const accountId = merged.accountId;
+	const enabled = merged.enabled !== false;
+	const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		sendReadReceipts: merged.sendReadReceipts ?? true,
+		messagePrefix: merged.messagePrefix ?? params.cfg.messages?.messagePrefix,
+		defaultTo: merged.defaultTo,
+		authDir,
+		isLegacyAuthDir: isLegacy,
+		selfChatMode: merged.selfChatMode,
+		dmPolicy: merged.dmPolicy,
+		allowFrom: merged.allowFrom,
+		groupAllowFrom: merged.groupAllowFrom,
+		groupPolicy: merged.groupPolicy,
+		historyLimit: merged.historyLimit,
+		textChunkLimit: merged.textChunkLimit,
+		chunkMode: merged.chunkMode,
+		mediaMaxMb: merged.mediaMaxMb,
+		blockStreaming: merged.blockStreaming,
+		ackReaction: merged.ackReaction,
+		reactionLevel: merged.reactionLevel,
+		groups: merged.groups,
+		direct: merged.direct,
+		debounceMs: merged.debounceMs,
+		replyToMode: merged.replyToMode
+	};
+}
+function resolveWhatsAppMediaMaxBytes(account) {
+	return (typeof account.mediaMaxMb === "number" && account.mediaMaxMb > 0 ? account.mediaMaxMb : 50) * 1024 * 1024;
+}
+function listEnabledWhatsAppAccounts(cfg) {
+	return listAccountIds(cfg).map((accountId) => resolveWhatsAppAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveWhatsAppAccount as a, listWhatsAppAuthDirs as i, hasAnyWhatsAppAuth as n, resolveWhatsAppAuthDir as o, listEnabledWhatsAppAccounts as r, resolveWhatsAppMediaMaxBytes as s, DEFAULT_WHATSAPP_MEDIA_MAX_MB as t };

package/dist/action-runtime-DTGNgG-i.js

@@ -0,0 +1,74 @@
+import { a as resolveWhatsAppAccount } from "./accounts-BDqgpFEB.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CN-Wo6IY.js";
+import { t as resolveWhatsAppReactionLevel } from "./reaction-level-CRVEVAfi.js";
+import { r as sendReactionWhatsApp } from "./send-CIyLFxdZ.js";
+import { ToolAuthorizationError, createActionGate, jsonResult, readReactionParams, readStringParam } from "openclaw/plugin-sdk/channel-actions";
+//#region extensions/whatsapp/src/action-runtime-target-auth.ts
+function resolveAuthorizedWhatsAppOutboundTarget(params) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const resolution = resolveWhatsAppOutboundTarget({
+		to: params.chatJid,
+		allowFrom: account.allowFrom ?? [],
+		mode: "implicit"
+	});
+	if (!resolution.ok) throw new ToolAuthorizationError(`WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`);
+	return {
+		to: resolution.to,
+		accountId: account.accountId
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/action-runtime.ts
+const whatsAppActionRuntime = {
+	resolveAuthorizedWhatsAppOutboundTarget,
+	sendReactionWhatsApp
+};
+async function handleWhatsAppAction(params, cfg) {
+	const action = readStringParam(params, "action", { required: true });
+	const whatsAppConfig = cfg.channels?.whatsapp;
+	const isActionEnabled = createActionGate(whatsAppConfig?.actions);
+	if (action === "react") {
+		const accountId = readStringParam(params, "accountId");
+		if (!whatsAppConfig) throw new Error("WhatsApp reactions are disabled.");
+		if (!isActionEnabled("reactions")) throw new Error("WhatsApp reactions are disabled.");
+		const reactionLevelInfo = resolveWhatsAppReactionLevel({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`WhatsApp agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.whatsapp.reactionLevel to "minimal" or "extensive" to enable.`);
+		const chatJid = readStringParam(params, "chatJid", { required: true });
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a WhatsApp reaction." });
+		const participant = readStringParam(params, "participant");
+		const fromMeRaw = params.fromMe;
+		const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : void 0;
+		const resolved = whatsAppActionRuntime.resolveAuthorizedWhatsAppOutboundTarget({
+			cfg,
+			chatJid,
+			accountId,
+			actionLabel: "reaction"
+		});
+		const resolvedEmoji = remove ? "" : emoji;
+		await whatsAppActionRuntime.sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
+			verbose: false,
+			fromMe,
+			participant: participant ?? void 0,
+			accountId: resolved.accountId,
+			cfg
+		});
+		if (!remove && !isEmpty) return jsonResult({
+			ok: true,
+			added: emoji
+		});
+		return jsonResult({
+			ok: true,
+			removed: true
+		});
+	}
+	throw new Error(`Unsupported WhatsApp action: ${action}`);
+}
+//#endregion
+export { whatsAppActionRuntime as n, handleWhatsAppAction as t };

package/dist/action-runtime-api.js

@@ -0,0 +1,2 @@
+import { t as handleWhatsAppAction } from "./action-runtime-DTGNgG-i.js";
+export { handleWhatsAppAction };

package/dist/action-runtime.runtime.js

@@ -0,0 +1,2 @@
+import { t as handleWhatsAppAction } from "./action-runtime-DTGNgG-i.js";
+export { handleWhatsAppAction };

package/dist/active-listener-N7GFKsuN.js

@@ -0,0 +1,11 @@
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-DG18xddX.js";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-D_iIGz5m.js";
+//#region extensions/whatsapp/src/active-listener.ts
+function resolveWebAccountId(params) {
+	return (params.accountId ?? "").trim() || resolveDefaultWhatsAppAccountId(params.cfg);
+}
+function getActiveWebListener(accountId) {
+	return getRegisteredWhatsAppConnectionController(accountId)?.getActiveListener() ?? null;
+}
+//#endregion
+export { resolveWebAccountId as n, getActiveWebListener as t };

package/dist/agent-tools-login-DpRxLNRB.js

@@ -0,0 +1,89 @@
+import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
+import "./login-qr-api.js";
+import { Type } from "typebox";
+//#region extensions/whatsapp/src/agent-tools-login.ts
+const QR_DATA_URL_MAX_LENGTH = 16384;
+function readOptionalString(value) {
+	return typeof value === "string" && value.trim() ? value : void 0;
+}
+function createWhatsAppLoginTool() {
+	return {
+		label: "WhatsApp Login",
+		name: "whatsapp_login",
+		ownerOnly: true,
+		description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+		parameters: Type.Object({
+			action: Type.Unsafe({
+				type: "string",
+				enum: ["start", "wait"]
+			}),
+			timeoutMs: Type.Optional(Type.Number()),
+			force: Type.Optional(Type.Boolean()),
+			accountId: Type.Optional(Type.String()),
+			currentQrDataUrl: Type.Optional(Type.String({
+				maxLength: QR_DATA_URL_MAX_LENGTH,
+				pattern: "^data:image/png;base64,"
+			}))
+		}),
+		execute: async (_toolCallId, args) => {
+			const renderQrReply = (params) => {
+				return {
+					content: [{
+						type: "text",
+						text: [
+							params.message,
+							"",
+							"Open WhatsApp → Linked Devices and scan:",
+							"",
+							`![whatsapp-qr](${params.qrDataUrl})`
+						].join("\n")
+					}],
+					details: {
+						connected: params.connected ?? false,
+						qr: true
+					}
+				};
+			};
+			const action = args?.action ?? "start";
+			const accountId = readOptionalString(args.accountId);
+			if (action === "wait") {
+				const result = await waitForWebLogin({
+					accountId,
+					timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : void 0,
+					currentQrDataUrl: readOptionalString(args.currentQrDataUrl)
+				});
+				if (result.qrDataUrl) return renderQrReply({
+					message: result.message,
+					qrDataUrl: result.qrDataUrl,
+					connected: result.connected
+				});
+				return {
+					content: [{
+						type: "text",
+						text: result.message
+					}],
+					details: { connected: result.connected }
+				};
+			}
+			const result = await startWebLoginWithQr({
+				accountId,
+				timeoutMs: typeof args.timeoutMs === "number" ? args.timeoutMs : void 0,
+				force: typeof args.force === "boolean" ? args.force : false
+			});
+			if (!result.qrDataUrl) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				details: { qr: false }
+			};
+			return renderQrReply({
+				message: result.message,
+				qrDataUrl: result.qrDataUrl,
+				connected: result.connected
+			});
+		}
+	};
+}
+//#endregion
+export { createWhatsAppLoginTool as t };