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

package/dist/normalize-CWYiGkXw.js

@@ -0,0 +1,2 @@
+import "./normalize-target-BPVHNsM5.js";
+export {};

package/dist/normalize-target-BPVHNsM5.js

@@ -0,0 +1,74 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/text-runtime";
+import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
+//#region extensions/whatsapp/src/normalize-target.ts
+const WHATSAPP_USER_JID_RE = /^(\d+)(?::\d+)?@s\.whatsapp\.net$/i;
+const WHATSAPP_LEGACY_USER_JID_RE = /^(\d+)@c\.us$/i;
+const WHATSAPP_LID_RE = /^(\d+)@lid$/i;
+const NON_WHATSAPP_PROVIDER_PREFIX_RE = /^[a-z][a-z0-9-]*:/i;
+const WHATSAPP_NEWSLETTER_JID_RE = /^([0-9]+)@newsletter$/i;
+function stripWhatsAppTargetPrefixes(value) {
+	let candidate = value.trim();
+	for (;;) {
+		const before = candidate;
+		candidate = candidate.replace(/^whatsapp:/i, "").trim();
+		if (candidate === before) return candidate;
+	}
+}
+function isWhatsAppGroupJid(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	if (!normalizeLowercaseStringOrEmpty(candidate).endsWith("@g.us")) return false;
+	const localPart = candidate.slice(0, candidate.length - 5);
+	if (!localPart || localPart.includes("@")) return false;
+	return /^[0-9]+(-[0-9]+)*$/.test(localPart);
+}
+function isWhatsAppNewsletterJid(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	return WHATSAPP_NEWSLETTER_JID_RE.test(candidate);
+}
+function isWhatsAppUserTarget(value) {
+	const candidate = stripWhatsAppTargetPrefixes(value);
+	return WHATSAPP_USER_JID_RE.test(candidate) || WHATSAPP_LEGACY_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 legacyUserMatch = jid.match(WHATSAPP_LEGACY_USER_JID_RE);
+	if (legacyUserMatch) return legacyUserMatch[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)) return `${candidate.slice(0, candidate.length - 5)}@g.us`;
+	if (isWhatsAppNewsletterJid(candidate)) {
+		const match = candidate.match(WHATSAPP_NEWSLETTER_JID_RE);
+		return match ? `${match[1]}@newsletter` : null;
+	}
+	if (isWhatsAppUserTarget(candidate)) {
+		const phone = extractUserJidPhone(candidate);
+		if (!phone) return null;
+		const normalized = normalizeE164(phone);
+		return normalized.length > 1 ? normalized : null;
+	}
+	if (candidate.includes("@")) return null;
+	if (NON_WHATSAPP_PROVIDER_PREFIX_RE.test(candidate)) return null;
+	const normalized = normalizeE164(candidate);
+	return normalized.length > 1 ? normalized : null;
+}
+function normalizeWhatsAppMessagingTarget(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	return normalizeWhatsAppTarget(trimmed) ?? void 0;
+}
+function normalizeWhatsAppAllowFromEntries(allowFrom) {
+	return allowFrom.map((entry) => String(entry).trim()).filter((entry) => Boolean(entry)).map((entry) => entry === "*" ? entry : normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+}
+function looksLikeWhatsAppTargetId(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return false;
+	return /^whatsapp:/i.test(trimmed) || isWhatsAppGroupJid(trimmed) || isWhatsAppNewsletterJid(trimmed) || isWhatsAppUserTarget(trimmed) || normalizeWhatsAppTarget(trimmed) !== null;
+}
+//#endregion
+export { normalizeWhatsAppAllowFromEntries as a, looksLikeWhatsAppTargetId as i, isWhatsAppNewsletterJid as n, normalizeWhatsAppMessagingTarget as o, isWhatsAppUserTarget as r, normalizeWhatsAppTarget as s, isWhatsAppGroupJid as t };

package/dist/outbound-adapter-BssVnZdz.js

@@ -0,0 +1,29 @@
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CN-Wo6IY.js";
+import { n as normalizeWhatsAppPayloadText } from "./outbound-media-contract-CGss_QHy.js";
+import { t as createWhatsAppOutboundBase } from "./outbound-base-Bq1UYEK5.js";
+import { shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { chunkText } from "openclaw/plugin-sdk/reply-chunking";
+//#region extensions/whatsapp/src/outbound-adapter.ts
+let whatsAppSendModulePromise;
+function loadWhatsAppSendModule() {
+	whatsAppSendModulePromise ??= import("./send-CIyLFxdZ.js").then((n) => n.a);
+	return whatsAppSendModulePromise;
+}
+function normalizeOutboundText(text) {
+	return normalizeWhatsAppPayloadText(text);
+}
+const whatsappOutbound = createWhatsAppOutboundBase({
+	chunker: chunkText,
+	sendMessageWhatsApp: async (to, text, options) => await (await loadWhatsAppSendModule()).sendMessageWhatsApp(to, normalizeOutboundText(text), { ...options }),
+	sendPollWhatsApp: async (to, poll, options) => await (await loadWhatsAppSendModule()).sendPollWhatsApp(to, poll, options),
+	shouldLogVerbose: () => shouldLogVerbose(),
+	resolveTarget: ({ to, allowFrom, mode }) => resolveWhatsAppOutboundTarget({
+		to,
+		allowFrom,
+		mode
+	}),
+	normalizeText: normalizeOutboundText,
+	skipEmptyText: true
+});
+//#endregion
+export { whatsappOutbound as t };

package/dist/outbound-base-Bq1UYEK5.js

@@ -0,0 +1,119 @@
+import { s as toWhatsappJid } from "./text-runtime-C1zNiZeO.js";
+import { n as normalizeWhatsAppPayloadText, t as normalizeWhatsAppOutboundPayload } from "./outbound-media-contract-CGss_QHy.js";
+import { i as lookupInboundMessageMetaForTarget } from "./quoted-message-TENQzyxV.js";
+import { DEFAULT_ACCOUNT_ID, listCombinedAccountIds, normalizeOptionalAccountId, resolveListedDefaultAccountId } from "openclaw/plugin-sdk/account-core";
+import { createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
+import { resolveOutboundSendDep } from "openclaw/plugin-sdk/outbound-send-deps";
+import { sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
+//#region extensions/whatsapp/src/outbound-send-deps.ts
+const WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS = ["sendWhatsApp"];
+//#endregion
+//#region extensions/whatsapp/src/outbound-base.ts
+function resolveQuoteLookupAccountId(cfg, accountId) {
+	const explicitAccountId = normalizeOptionalAccountId(accountId);
+	if (explicitAccountId) return explicitAccountId;
+	const channelCfg = cfg?.channels?.whatsapp;
+	return resolveListedDefaultAccountId({
+		accountIds: listCombinedAccountIds({
+			configuredAccountIds: channelCfg?.accounts && typeof channelCfg.accounts === "object" ? Object.keys(channelCfg.accounts).filter(Boolean) : [],
+			fallbackAccountIdWhenEmpty: DEFAULT_ACCOUNT_ID
+		}),
+		configuredDefaultAccountId: normalizeOptionalAccountId(channelCfg?.defaultAccount)
+	});
+}
+function createWhatsAppOutboundBase({ chunker, sendMessageWhatsApp, sendPollWhatsApp, shouldLogVerbose, resolveTarget, normalizeText = normalizeWhatsAppPayloadText, skipEmptyText = true }) {
+	const resolveQuotedMessageKey = (params) => {
+		const replyToId = params.replyToId?.trim();
+		if (!replyToId) return;
+		const targetJid = toWhatsappJid(params.to);
+		const cachedMeta = lookupInboundMessageMetaForTarget(params.accountId, targetJid, replyToId);
+		return {
+			id: replyToId,
+			remoteJid: cachedMeta?.remoteJid ?? targetJid,
+			fromMe: cachedMeta?.fromMe ?? false,
+			participant: cachedMeta?.participant,
+			messageText: cachedMeta?.body
+		};
+	};
+	const outbound = {
+		deliveryMode: "gateway",
+		chunker,
+		chunkerMode: "text",
+		textChunkLimit: 4e3,
+		sanitizeText: ({ text }) => normalizeText(text),
+		pollMaxOptions: 12,
+		resolveTarget,
+		...createAttachedChannelResultAdapter({
+			channel: "whatsapp",
+			sendText: async ({ cfg, to, text, accountId, deps, gifPlayback, replyToId }) => {
+				const normalizedText = normalizeText(text);
+				if (skipEmptyText && !normalizedText) return { messageId: "" };
+				const send = resolveOutboundSendDep(deps, "whatsapp", { legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageWhatsApp;
+				const quotedMessageKey = resolveQuotedMessageKey({
+					accountId: resolveQuoteLookupAccountId(cfg, accountId),
+					to,
+					replyToId
+				});
+				return await send(to, normalizedText, {
+					verbose: false,
+					cfg,
+					accountId: accountId ?? void 0,
+					gifPlayback,
+					quotedMessageKey
+				});
+			},
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, audioAsVoice, accountId, deps, gifPlayback, replyToId }) => {
+				const send = resolveOutboundSendDep(deps, "whatsapp", { legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageWhatsApp;
+				const quotedMessageKey = resolveQuotedMessageKey({
+					accountId: resolveQuoteLookupAccountId(cfg, accountId),
+					to,
+					replyToId
+				});
+				return await send(to, normalizeText(text), {
+					verbose: false,
+					cfg,
+					mediaUrl,
+					mediaAccess,
+					mediaLocalRoots,
+					mediaReadFile,
+					...audioAsVoice === void 0 ? {} : { audioAsVoice },
+					accountId: accountId ?? void 0,
+					gifPlayback,
+					quotedMessageKey
+				});
+			},
+			sendPoll: async ({ cfg, to, poll, accountId }) => await sendPollWhatsApp(to, poll, {
+				verbose: shouldLogVerbose(),
+				accountId: accountId ?? void 0,
+				cfg
+			})
+		})
+	};
+	return {
+		...outbound,
+		sendPayload: async (ctx) => {
+			if (ctx.payload.isError === true) return {
+				channel: "whatsapp",
+				messageId: ""
+			};
+			const payload = normalizeWhatsAppOutboundPayload(ctx.payload, { normalizeText });
+			if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
+				if (ctx.payload.interactive || ctx.payload.presentation || ctx.payload.channelData) throw new Error("WhatsApp sendPayload does not support structured-only payloads without text or media.");
+				return {
+					channel: "whatsapp",
+					messageId: ""
+				};
+			}
+			return await sendTextMediaPayload({
+				channel: "whatsapp",
+				ctx: {
+					...ctx,
+					payload
+				},
+				adapter: outbound
+			});
+		}
+	};
+}
+//#endregion
+export { WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS as n, createWhatsAppOutboundBase as t };

package/dist/outbound-media-contract-CGss_QHy.js

@@ -0,0 +1,163 @@
+import { t as formatError } from "./session-errors-CSuKZPub.js";
+import { t as text_runtime_exports } from "./text-runtime-C1zNiZeO.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+import { MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS, runFfmpeg } from "openclaw/plugin-sdk/media-runtime";
+import { sanitizeForPlainText } from "openclaw/plugin-sdk/outbound-runtime";
+import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
+//#region extensions/whatsapp/src/outbound-media-contract.ts
+const WHATSAPP_VOICE_FILE_NAME = "voice.ogg";
+const WHATSAPP_VOICE_SAMPLE_RATE_HZ = 48e3;
+const WHATSAPP_VOICE_BITRATE = "64k";
+const WHATSAPP_VOICE_MIMETYPE = "audio/ogg; codecs=opus";
+function stripWhatsAppPluralToolXml(text) {
+	return (0, text_runtime_exports.stripToolCallXmlTags)(text, { stripFunctionCallsXmlPayloads: true });
+}
+function finalizeWhatsAppVisibleText(text) {
+	return sanitizeForPlainText(stripWhatsAppPluralToolXml(text));
+}
+function normalizeWhatsAppPayloadText(text) {
+	return finalizeWhatsAppVisibleText((0, text_runtime_exports.sanitizeAssistantVisibleText)(text ?? "")).trimStart();
+}
+function stripLeadingBlankLines(text) {
+	return text.replace(/^(?:[ \t]*\r?\n)+/, "");
+}
+function normalizeWhatsAppPayloadTextPreservingIndentation(text) {
+	const normalized = stripLeadingBlankLines(finalizeWhatsAppVisibleText((0, text_runtime_exports.sanitizeAssistantVisibleTextWithProfile)(stripLeadingBlankLines(text ?? ""), "history")));
+	return normalized.trim() ? normalized : "";
+}
+function resolveWhatsAppOutboundMediaUrls(payload) {
+	const orderedMediaUrls = [payload.mediaUrl?.trim(), ...(payload.mediaUrls ? [...payload.mediaUrls] : []).map((entry) => entry.trim()).filter((entry) => Boolean(entry))].filter((entry) => Boolean(entry));
+	return Array.from(new Set(orderedMediaUrls));
+}
+function normalizeWhatsAppOutboundPayload(payload, options) {
+	const mediaUrls = resolveWhatsAppOutboundMediaUrls(payload);
+	const normalizeText = options?.normalizeText ?? normalizeWhatsAppPayloadText;
+	return {
+		...payload,
+		text: normalizeText(payload.text),
+		mediaUrl: mediaUrls[0],
+		mediaUrls: mediaUrls.length > 0 ? mediaUrls : void 0
+	};
+}
+function normalizeWhatsAppLoadedMedia(media, mediaUrl) {
+	const kind = media.kind === "image" || media.kind === "audio" || media.kind === "video" ? media.kind : "document";
+	const mimetype = kind === "audio" && isWhatsAppNativeVoiceAudio({
+		contentType: media.contentType,
+		mediaUrl
+	}) ? WHATSAPP_VOICE_MIMETYPE : media.contentType ?? "application/octet-stream";
+	const fileName = kind === "document" ? media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl) ?? "file" : void 0;
+	return {
+		buffer: media.buffer,
+		kind,
+		mimetype,
+		...fileName ? { fileName } : {}
+	};
+}
+async function prepareWhatsAppOutboundMedia(media, mediaUrl) {
+	const normalized = normalizeWhatsAppLoadedMedia(media, mediaUrl);
+	if (normalized.kind !== "audio") return normalized;
+	if (isWhatsAppNativeVoiceAudio({
+		contentType: media.contentType,
+		fileName: media.fileName,
+		mediaUrl
+	})) return normalized;
+	return {
+		buffer: await transcodeToWhatsAppVoiceOpus({
+			buffer: media.buffer,
+			fileName: media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl) ?? "audio"
+		}),
+		kind: "audio",
+		mimetype: WHATSAPP_VOICE_MIMETYPE
+	};
+}
+function normalizeContentType(value) {
+	return value?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+}
+function isWhatsAppNativeVoiceAudio(params) {
+	const contentType = normalizeContentType(params.contentType);
+	if (contentType === "audio/ogg" || contentType === "audio/opus") return true;
+	const fileName = params.fileName ?? deriveWhatsAppDocumentFileName(params.mediaUrl) ?? "";
+	const ext = path.extname(fileName).toLowerCase();
+	return ext === ".ogg" || ext === ".opus";
+}
+async function transcodeToWhatsAppVoiceOpus(params) {
+	const tempRoot = resolvePreferredOpenClawTmpDir();
+	await fs.mkdir(tempRoot, {
+		recursive: true,
+		mode: 448
+	});
+	const tempDir = await fs.mkdtemp(path.join(tempRoot, "whatsapp-voice-"));
+	try {
+		const ext = path.extname(params.fileName).toLowerCase();
+		const inputExt = ext && ext.length <= 12 ? ext : ".audio";
+		const inputPath = path.join(tempDir, `input${inputExt}`);
+		const outputPath = path.join(tempDir, WHATSAPP_VOICE_FILE_NAME);
+		await fs.writeFile(inputPath, params.buffer, { mode: 384 });
+		await runFfmpeg([
+			"-hide_banner",
+			"-loglevel",
+			"error",
+			"-y",
+			"-i",
+			inputPath,
+			"-vn",
+			"-sn",
+			"-dn",
+			"-t",
+			String(MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS),
+			"-ar",
+			String(WHATSAPP_VOICE_SAMPLE_RATE_HZ),
+			"-ac",
+			"1",
+			"-c:a",
+			"libopus",
+			"-b:a",
+			WHATSAPP_VOICE_BITRATE,
+			outputPath
+		]);
+		return await fs.readFile(outputPath);
+	} finally {
+		await fs.rm(tempDir, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+function deriveWhatsAppDocumentFileName(mediaUrl) {
+	if (!mediaUrl) return;
+	try {
+		const parsed = new URL(mediaUrl);
+		const fileName = path.posix.basename(parsed.pathname);
+		return fileName ? decodeURIComponent(fileName) : void 0;
+	} catch {
+		return (mediaUrl.split(/[?#]/, 1)[0] ?? "").split(/[\\/]/).pop() || void 0;
+	}
+}
+function isRetryableWhatsAppOutboundError(error) {
+	return /closed|reset|timed\s*out|disconnect/i.test(formatError(error));
+}
+async function sendWhatsAppOutboundWithRetry(params) {
+	const maxAttempts = params.maxAttempts ?? 3;
+	let lastError;
+	for (let attempt = 1; attempt <= maxAttempts; attempt += 1) try {
+		return await params.send();
+	} catch (error) {
+		lastError = error;
+		const errorText = formatError(error);
+		const isLastAttempt = attempt === maxAttempts;
+		if (!isRetryableWhatsAppOutboundError(error) || isLastAttempt) throw error;
+		const backoffMs = 500 * attempt;
+		await params.onRetry?.({
+			attempt,
+			maxAttempts,
+			backoffMs,
+			error,
+			errorText
+		});
+		await (0, text_runtime_exports.sleep)(backoffMs);
+	}
+	throw lastError;
+}
+//#endregion
+export { resolveWhatsAppOutboundMediaUrls as a, prepareWhatsAppOutboundMedia as i, normalizeWhatsAppPayloadText as n, sendWhatsAppOutboundWithRetry as o, normalizeWhatsAppPayloadTextPreservingIndentation as r, normalizeWhatsAppOutboundPayload as t };

package/dist/outbound-payload-test-api.js

@@ -0,0 +1,2 @@
+import { t as whatsappOutbound } from "./outbound-adapter-BssVnZdz.js";
+export { whatsappOutbound };

package/dist/quoted-message-TENQzyxV.js

@@ -0,0 +1,108 @@
+import { i as jidToE164 } from "./text-runtime-C1zNiZeO.js";
+//#region extensions/whatsapp/src/quoted-message.ts
+const CACHE_TTL_MS = 600 * 1e3;
+const MAX_ENTRIES = 500;
+const cache = /* @__PURE__ */ new Map();
+function makeCacheKey(accountId, remoteJid, messageId) {
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function cacheInboundMessageMeta(accountId, remoteJid, messageId, meta) {
+	if (!accountId || !messageId || !remoteJid) return;
+	if (cache.size >= MAX_ENTRIES) {
+		const oldest = cache.keys().next().value;
+		if (oldest) cache.delete(oldest);
+	}
+	cache.set(makeCacheKey(accountId, remoteJid, messageId), {
+		...meta,
+		ts: Date.now()
+	});
+}
+function lookupInboundMessageMeta(accountId, remoteJid, messageId) {
+	const cacheKey = makeCacheKey(accountId, remoteJid, messageId);
+	const entry = cache.get(cacheKey);
+	if (!entry) return;
+	if (Date.now() - entry.ts > CACHE_TTL_MS) {
+		cache.delete(cacheKey);
+		return;
+	}
+	return {
+		participant: entry.participant,
+		participantE164: entry.participantE164,
+		body: entry.body,
+		fromMe: entry.fromMe
+	};
+}
+function normalizeComparableJid(jid) {
+	return jid?.trim().replace(/:\d+/, "").toLowerCase() || void 0;
+}
+function isGroupJid(jid) {
+	return Boolean(jid && jid.endsWith("@g.us"));
+}
+function areComparableE164sEqual(left, right) {
+	const normalizedLeft = left?.trim();
+	const normalizedRight = right?.trim();
+	if (!normalizedLeft || !normalizedRight) return false;
+	return normalizedLeft === normalizedRight;
+}
+function areComparableJidsEqual(left, right) {
+	const normalizedLeft = normalizeComparableJid(left);
+	const normalizedRight = normalizeComparableJid(right);
+	if (!normalizedLeft || !normalizedRight) return false;
+	if (normalizedLeft === normalizedRight) return true;
+	const leftE164 = jidToE164(normalizedLeft);
+	const rightE164 = jidToE164(normalizedRight);
+	return Boolean(leftE164 && rightE164 && leftE164 === rightE164);
+}
+function matchesQuotedConversationTarget(targetJid, candidate) {
+	if (areComparableJidsEqual(targetJid, candidate.remoteJid)) return true;
+	if (isGroupJid(targetJid) || isGroupJid(candidate.remoteJid)) return false;
+	return areComparableJidsEqual(targetJid, candidate.participant) || areComparableE164sEqual(jidToE164(targetJid) ?? void 0, candidate.participantE164);
+}
+function lookupInboundMessageMetaForTarget(accountId, targetJid, messageId) {
+	if (!accountId || !messageId || !targetJid) return;
+	const exact = lookupInboundMessageMeta(accountId, targetJid, messageId);
+	if (exact) return {
+		remoteJid: targetJid,
+		participant: exact.participant,
+		participantE164: exact.participantE164,
+		body: exact.body,
+		fromMe: exact.fromMe
+	};
+	const prefix = `${accountId}:`;
+	const suffix = `:${messageId}`;
+	let matched;
+	for (const [cacheKey, entry] of cache.entries()) {
+		if (!cacheKey.startsWith(prefix) || !cacheKey.endsWith(suffix)) continue;
+		if (Date.now() - entry.ts > CACHE_TTL_MS) {
+			cache.delete(cacheKey);
+			continue;
+		}
+		const candidate = {
+			remoteJid: cacheKey.slice(prefix.length, cacheKey.length - suffix.length),
+			participant: entry.participant,
+			participantE164: entry.participantE164,
+			body: entry.body,
+			fromMe: entry.fromMe
+		};
+		if (!matchesQuotedConversationTarget(targetJid, candidate)) continue;
+		if (matched) return;
+		matched = candidate;
+	}
+	return matched;
+}
+function buildQuotedMessageOptions(params) {
+	const id = params.messageId?.trim();
+	const remoteJid = params.remoteJid?.trim();
+	if (!id || !remoteJid) return;
+	return { quoted: {
+		key: {
+			remoteJid,
+			id,
+			fromMe: params.fromMe ?? false,
+			participant: params.participant
+		},
+		message: { conversation: params.messageText ?? "" }
+	} };
+}
+//#endregion
+export { lookupInboundMessageMetaForTarget as i, cacheInboundMessageMeta as n, lookupInboundMessageMeta as r, buildQuotedMessageOptions as t };

package/dist/reaction-level-CRVEVAfi.js

@@ -0,0 +1,16 @@
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-CNQ33oav.js";
+import { resolveReactionLevel } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/whatsapp/src/reaction-level.ts
+/** Resolve the effective reaction level and its implications for WhatsApp. */
+function resolveWhatsAppReactionLevel(params) {
+	return resolveReactionLevel({
+		value: resolveMergedWhatsAppAccountConfig({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}).reactionLevel,
+		defaultLevel: "minimal",
+		invalidFallback: "minimal"
+	});
+}
+//#endregion
+export { resolveWhatsAppReactionLevel as t };

package/dist/reply-resolver.runtime-BRCgoO4C.js

@@ -0,0 +1,2 @@
+import { getReplyFromConfig } from "openclaw/plugin-sdk/reply-runtime";
+export { getReplyFromConfig };

package/dist/resolve-outbound-target-CN-Wo6IY.js

@@ -0,0 +1,39 @@
+import { n as isWhatsAppNewsletterJid, s as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-BPVHNsM5.js";
+import { missingTargetError } from "openclaw/plugin-sdk/channel-feedback";
+//#region extensions/whatsapp/src/resolve-outbound-target.ts
+function whatsappAllowFromPolicyError(target) {
+	return /* @__PURE__ */ new Error(`Target "${target}" is not listed in the configured WhatsApp allowFrom policy.`);
+}
+function resolveWhatsAppOutboundTarget(params) {
+	const trimmed = params.to?.trim() ?? "";
+	if (!trimmed) return {
+		ok: false,
+		error: missingTargetError("WhatsApp", "<E.164|group JID|newsletter JID>")
+	};
+	const normalizedTo = normalizeWhatsAppTarget(trimmed);
+	if (!normalizedTo) return {
+		ok: false,
+		error: missingTargetError("WhatsApp", "<E.164|group JID|newsletter JID>")
+	};
+	if (isWhatsAppGroupJid(normalizedTo) || isWhatsAppNewsletterJid(normalizedTo)) return {
+		ok: true,
+		to: normalizedTo
+	};
+	const allowListRaw = (params.allowFrom ?? []).map((entry) => String(entry).trim()).filter(Boolean);
+	const hasWildcard = allowListRaw.includes("*");
+	const allowList = allowListRaw.filter((entry) => entry !== "*").map((entry) => normalizeWhatsAppTarget(entry)).filter((entry) => Boolean(entry));
+	if (hasWildcard || allowList.length === 0) return {
+		ok: true,
+		to: normalizedTo
+	};
+	if (allowList.includes(normalizedTo)) return {
+		ok: true,
+		to: normalizedTo
+	};
+	return {
+		ok: false,
+		error: whatsappAllowFromPolicyError(normalizedTo)
+	};
+}
+//#endregion
+export { resolveWhatsAppOutboundTarget as t };

package/dist/rolldown-runtime-RkAeH_Qm.js

@@ -0,0 +1,27 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+//#endregion
+export { __reExport as n, __exportAll as t };

package/dist/runtime-6fZ67abR.js

@@ -0,0 +1,8 @@
+import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
+//#region extensions/whatsapp/src/runtime.ts
+const { setRuntime: setWhatsAppRuntime, getRuntime: getWhatsAppRuntime } = createPluginRuntimeStore({
+	pluginId: "whatsapp",
+	errorMessage: "WhatsApp runtime not initialized"
+});
+//#endregion
+export { setWhatsAppRuntime as n, getWhatsAppRuntime as t };

package/dist/runtime-api.js

@@ -0,0 +1,15 @@
+import { n as resolveWebCredsBackupPath, r as resolveWebCredsPath, t as hasWebCredsSync } from "./creds-files-_2V8jzQa.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-DTGNgG-i.js";
+import { n as getStatusCode, t as formatError } from "./session-errors-CSuKZPub.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-CIyLFxdZ.js";
+import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
+import { t as createWhatsAppLoginTool } from "./agent-tools-login-DpRxLNRB.js";
+import { n as setWhatsAppRuntime } from "./runtime-6fZ67abR.js";
+import { C as waitForCredsSaveQueueWithTimeout, S as waitForCredsSaveQueue, _ as readWebSelfIdentityForDecision, a as getWebAuthAgeMs, b as webAuthExists, c as pickWebChannel, d as readWebAuthExistsForDecision, f as readWebAuthSnapshot, g as readWebSelfIdentity, h as readWebSelfId, i as formatWhatsAppWebAuthStatusState, l as readCredsJsonRaw, m as readWebAuthState, n as WHATSAPP_AUTH_UNSTABLE_CODE, o as logWebSelfId, p as readWebAuthSnapshotBestEffort, r as WhatsAppAuthUnstableError, s as logoutWeb, t as WA_WEB_AUTH_DIR, u as readWebAuthExistsBestEffort, v as resolveDefaultWebAuthDir, w as writeCredsJsonAtomically, y as restoreCredsFromBackupIfNeeded } from "./auth-store-BjCb50Ry.js";
+import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-DLGCIbfl.js";
+import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-N7GFKsuN.js";
+import { c as waitForWaConnection, o as createWaSocket, s as newConnectionId } from "./connection-controller-BiHAsTM8.js";
+import { a as loadWebMediaRaw, c as monitorWebInbox, d as extractMediaPlaceholder, f as extractText, i as loadWebMedia, l as extractContactContext, n as LocalMediaAccessError, o as optimizeImageToJpeg, p as resetWebInboundDedupe, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel, u as extractLocationData } from "./monitor-C4Fhg_lD.js";
+import { t as loginWeb } from "./login-DymdrKca.js";
+import { HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN, stripHeartbeatToken } from "openclaw/plugin-sdk/reply-runtime";
+export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, LocalMediaAccessError, SILENT_REPLY_TOKEN, WA_WEB_AUTH_DIR, WHATSAPP_AUTH_UNSTABLE_CODE, WhatsAppAuthUnstableError, createWaSocket, createWhatsAppLoginTool, extractContactContext, extractLocationData, extractMediaPlaceholder, extractText, formatError, formatWhatsAppWebAuthStatusState, getActiveWebListener, getDefaultLocalRoots, getStatusCode, getWebAuthAgeMs, handleWhatsAppAction, hasWebCredsSync, loadWebMedia, loadWebMediaRaw, logWebSelfId, loginWeb, logoutWeb, monitorWebChannel, monitorWebInbox, newConnectionId, optimizeImageToJpeg, optimizeImageToPng, pickWebChannel, readCredsJsonRaw, readWebAuthExistsBestEffort, readWebAuthExistsForDecision, readWebAuthSnapshot, readWebAuthSnapshotBestEffort, readWebAuthState, readWebSelfId, readWebSelfIdentity, readWebSelfIdentityForDecision, resetWebInboundDedupe, resolveDefaultWebAuthDir, resolveWebAccountId, resolveWebCredsBackupPath, resolveWebCredsPath, restoreCredsFromBackupIfNeeded, sendMessageWhatsApp, sendPollWhatsApp, sendReactionWhatsApp, sendTypingWhatsApp, setWhatsAppRuntime, startWebLoginWithQr, stripHeartbeatToken, waitForCredsSaveQueue, waitForCredsSaveQueueWithTimeout, waitForWaConnection, waitForWebLogin, webAuthExists, whatsAppActionRuntime, writeCredsJsonAtomically };

package/dist/runtime-group-policy-Gp1lQ0at.js

@@ -0,0 +1,11 @@
+import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
+//#region extensions/whatsapp/src/runtime-group-policy.ts
+function resolveWhatsAppRuntimeGroupPolicy(params) {
+	return resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy
+	});
+}
+//#endregion
+export { resolveWhatsAppRuntimeGroupPolicy as t };

package/dist/secret-contract-api.js

@@ -0,0 +1,5 @@
+//#region extensions/whatsapp/secret-contract-api.ts
+const secretTargetRegistryEntries = [];
+function collectRuntimeConfigAssignments() {}
+//#endregion
+export { collectRuntimeConfigAssignments, secretTargetRegistryEntries };

package/dist/security-contract-DqH8JDX6.js

@@ -0,0 +1,26 @@
+import { isRecord } from "openclaw/plugin-sdk/text-runtime";
+//#region extensions/whatsapp/src/security-contract.ts
+const unsupportedSecretRefSurfacePatterns = ["channels.whatsapp.creds.json", "channels.whatsapp.accounts.*.creds.json"];
+function collectUnsupportedSecretRefConfigCandidates(raw) {
+	if (!isRecord(raw)) return [];
+	if (!isRecord(raw.channels) || !isRecord(raw.channels.whatsapp)) return [];
+	const candidates = [];
+	const whatsapp = raw.channels.whatsapp;
+	const creds = isRecord(whatsapp.creds) ? whatsapp.creds : null;
+	if (creds) candidates.push({
+		path: "channels.whatsapp.creds.json",
+		value: creds.json
+	});
+	const accounts = isRecord(whatsapp.accounts) ? whatsapp.accounts : null;
+	if (!accounts) return candidates;
+	for (const [accountId, account] of Object.entries(accounts)) {
+		if (!isRecord(account) || !isRecord(account.creds)) continue;
+		candidates.push({
+			path: `channels.whatsapp.accounts.${accountId}.creds.json`,
+			value: account.creds.json
+		});
+	}
+	return candidates;
+}
+//#endregion
+export { unsupportedSecretRefSurfacePatterns as n, collectUnsupportedSecretRefConfigCandidates as t };