@openclaw/whatsapp 2026.7.1 → 2026.7.2-beta.2

package/dist/{access-control-DYE5dXna.js → access-control-DazDX3RB.js}

@@ -1,7 +1,7 @@
-import { a as resolveWhatsAppAccount } from "./accounts-4YgwroRU.js";
-import { n as isSelfChatMode } from "./targets-runtime-C-GiVn6Y.js";
-import { n as normalizeE164 } from "./text-runtime-DdX6-mC_.js";
-import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-Dqft3mFA.js";
+import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { n as isSelfChatMode } from "./targets-runtime-Bsh0HR9y.js";
+import { n as normalizeE164 } from "./text-runtime-BTGkMN0o.js";
+import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-D7L8LCuH.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";

package/dist/{account-config-6PTOSfaI.js → account-config-LiT9wWH9.js}

@@ -1,5 +1,4 @@
 import { DEFAULT_ACCOUNT_ID, mergeAccountConfig, resolveAccountEntry, resolveMergedAccountConfig } from "openclaw/plugin-sdk/account-core";
-import { resolveChannelStreamingBlockEnabled, resolveChannelStreamingChunkMode } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/whatsapp/src/account-config.ts
 function resolveWhatsAppDefaultAccountSharedConfig(cfg) {
 	const defaultAccount = resolveAccountEntry(cfg.channels?.whatsapp?.accounts, DEFAULT_ACCOUNT_ID);
@@ -32,15 +31,12 @@ function resolveMergedWhatsAppAccountConfig(params) {
 		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
+		...accountId === DEFAULT_ACCOUNT_ID ? base : resolveMergedNamedWhatsAppAccountConfig({
+			cfg: params.cfg,
+			accountId
+		})
 	};
 }
 //#endregion

package/dist/{accounts-4YgwroRU.js → accounts-CKOFMPf-.js}

@@ -1,4 +1,4 @@
-import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-6PTOSfaI.js";
+import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-LiT9wWH9.js";
 import { n as listConfiguredAccountIds, r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { n as hasWebCredsRegularFileSync, r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
 import fs from "node:fs";
@@ -89,9 +89,8 @@ function resolveWhatsAppAccount(params) {
 		mentionPatterns: merged.mentionPatterns,
 		historyLimit: merged.historyLimit,
 		textChunkLimit: merged.textChunkLimit,
-		chunkMode: merged.chunkMode,
+		streaming: merged.streaming,
 		mediaMaxMb: merged.mediaMaxMb,
-		blockStreaming: merged.blockStreaming,
 		ackReaction: merged.ackReaction,
 		reactionLevel: merged.reactionLevel,
 		groups: merged.groups,

package/dist/{action-runtime-DPahAqxV.js → action-runtime-Bf-12TIH.js}

@@ -1,6 +1,6 @@
-import { a as resolveWhatsAppAccount } from "./accounts-4YgwroRU.js";
-import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CcdugbDf.js";
-import { g as resolveWhatsAppReactionLevel, r as sendReactionWhatsApp } from "./send-C5CpFcBG.js";
+import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-BR97fAbB.js";
+import { r as sendReactionWhatsApp, u as resolveWhatsAppReactionLevel } from "./send-D9Ydnn4o.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) {

package/dist/action-runtime-api.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-DPahAqxV.js";
+import { t as handleWhatsAppAction } from "./action-runtime-Bf-12TIH.js";
 export { handleWhatsAppAction };

package/dist/action-runtime.runtime.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-DPahAqxV.js";
+import { t as handleWhatsAppAction } from "./action-runtime-Bf-12TIH.js";
 export { handleWhatsAppAction };

package/dist/{active-listener-B4SDebQ6.js → active-listener-5kHap439.js}

@@ -1,11 +1,11 @@
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.js";
+import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.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;
+	return getWhatsAppConnectionController(accountId)?.getActiveListener() ?? null;
 }
 //#endregion
 export { resolveWebAccountId as n, getActiveWebListener as t };

package/dist/{agent-tools-login-BX7eHgDm.js → agent-tools-login-DfyToBpG.js}

@@ -13,10 +13,7 @@ function createWhatsAppLoginTool() {
 		name: "whatsapp_login",
 		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"]
-			}),
+			action: Type.Enum(["start", "wait"], { type: "string" }),
 			timeoutMs: optionalPositiveIntegerSchema(),
 			force: Type.Optional(Type.Boolean()),
 			accountId: Type.Optional(Type.String()),

package/dist/api.js

@@ -1,29 +1,28 @@
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, i as listWhatsAppAuthDirs, n as hasAnyWhatsAppAuth, o as resolveWhatsAppAuthDir, r as listEnabledWhatsAppAccounts, s as resolveWhatsAppMediaMaxBytes, t as DEFAULT_WHATSAPP_MEDIA_MAX_MB } from "./accounts-4YgwroRU.js";
-import { a as normalizeWhatsAppAllowFromEntries, c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, r as isWhatsAppUserTarget, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.js";
-import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CcdugbDf.js";
-import "./send-C5CpFcBG.js";
-import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
-import { n as createWhatsAppSocketOperationTimeoutAdapter, t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DhbVFjah.js";
-import { c as toWhatsappJidWithLid, i as markdownToWhatsApp, n as isSelfChatMode, o as resolveJidToE164, r as jidToE164, s as toWhatsappJid, t as assertWebChannel } from "./targets-runtime-C-GiVn6Y.js";
-import { n as normalizeE164, r as resolveUserPath } from "./text-runtime-DdX6-mC_.js";
-import { n as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-BWp7h1uY.js";
+import { a as resolveWhatsAppAccount, i as listWhatsAppAuthDirs, n as hasAnyWhatsAppAuth, o as resolveWhatsAppAuthDir, r as listEnabledWhatsAppAccounts, s as resolveWhatsAppMediaMaxBytes, t as DEFAULT_WHATSAPP_MEDIA_MAX_MB } from "./accounts-CKOFMPf-.js";
+import { a as normalizeWhatsAppAllowFromEntries, c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, r as isWhatsAppUserTarget, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-BR97fAbB.js";
+import "./send-D9Ydnn4o.js";
+import { c as toWhatsappJidWithLid, i as markdownToWhatsApp, n as isSelfChatMode, o as resolveJidToE164, r as jidToE164, s as toWhatsappJid, t as assertWebChannel } from "./targets-runtime-Bsh0HR9y.js";
+import { n as normalizeE164, r as resolveUserPath } from "./text-runtime-BTGkMN0o.js";
+import { n as resolveWhatsAppGroupIntroHint, r as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-DbadDUDD.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy, s as resolveWhatsAppGroupIntroHint } from "./setup-core-DH-DFPLY.js";
-import "./config-schema-mBX2nmn1.js";
-import { t as whatsappSetupPlugin } from "./channel.setup-CURc5rEt.js";
+import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy } from "./setup-core-3aSOoK2T.js";
+import "./config-schema-BZ8h1hWA.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-BZ-po8fg.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-Dijefxc3.js";
-import { n as testing } from "./access-control-DYE5dXna.js";
-import { _ as extractLocationData, b as extractText, d as normalizeMessageContent, f as resolveInboundMediaMimetype, h as extractContextInfo, p as describeReplyContext, t as createWebSendApi } from "./send-api-DLlXl8CH.js";
-import { r as waitForWaConnection, t as createWaSocket } from "./session-DriaHt7V.js";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-CLBQrjtC.js";
+import { n as testing } from "./access-control-DazDX3RB.js";
+import { _ as extractLocationData, b as extractText, d as normalizeMessageContent, f as resolveInboundMediaMimetype, h as extractContextInfo, p as describeReplyContext, t as createWebSendApi } from "./send-api-W33lI2nR.js";
+import { a as createWhatsAppSocketOperationTimeoutAdapter, i as DEFAULT_WHATSAPP_SOCKET_TIMING, r as waitForWaConnection, t as createWaSocket } from "./session-mxWFn0eS.js";
+import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import "openclaw/plugin-sdk/channel-actions";
 import "openclaw/plugin-sdk/account-resolution";
 import "openclaw/plugin-sdk/core";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import "openclaw/plugin-sdk/account-id";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";
-createLazyRuntimeModule(() => import("./channel.runtime-CAssfx9p.js"));
+createLazyRuntimeModule(() => import("./channel.runtime-BDDy4Lhz.js"));
 //#endregion
 //#region extensions/whatsapp/src/qa-driver.runtime.ts
 function isRecord(value) {

package/dist/{approval-handler.runtime-DNWS4aYQ.js → approval-handler.runtime-CBiGQuZ5.js}

@@ -1,10 +1,14 @@
-import { s as normalizeWhatsAppMessagingTarget } from "./normalize-target-bVWjgftN.js";
-import { f as registerWhatsAppApprovalReactionTarget, i as sendTypingWhatsApp, p as unregisterWhatsAppApprovalReactionTarget, t as sendMessageWhatsApp } from "./send-C5CpFcBG.js";
-import "./normalize-Bxwqo-bW.js";
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
+import "./accounts-CKOFMPf-.js";
+import { s as normalizeWhatsAppMessagingTarget } from "./normalize-target-DSZnHkKF.js";
+import { i as sendTypingWhatsApp, t as sendMessageWhatsApp } from "./send-D9Ydnn4o.js";
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
+import "./normalize-C-Z16y7Q.js";
+import { i as unregisterWhatsAppApprovalReactionTarget, r as registerWhatsAppApprovalReactionTarget } from "./approval-reactions-BGQoz25s.js";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
-import { buildApprovalReactionPendingContent } from "openclaw/plugin-sdk/approval-reaction-runtime";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildApprovalReactionPendingContent } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { buildChannelApprovalExpiredText, buildChannelApprovalResolvedText, createChannelApprovalNativeRuntimeAdapter, resolvePreparedApprovalAccountId } from "openclaw/plugin-sdk/approval-handler-runtime";
 //#region extensions/whatsapp/src/approval-handler.runtime.ts
 const log = createSubsystemLogger("whatsapp/approvals");
@@ -40,14 +44,15 @@ const whatsappApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter(
 		})
 	},
 	transport: {
-		prepareTarget: ({ plannedTarget, accountId }) => {
+		prepareTarget: ({ cfg, plannedTarget, accountId }) => {
 			const to = normalizeWhatsAppMessagingTarget(plannedTarget.target.to);
 			if (!to) return null;
 			const prepared = {
 				to,
 				accountId: resolvePreparedApprovalAccountId({
 					plannedAccountId: plannedTarget.target.accountId,
-					contextAccountId: accountId
+					contextAccountId: accountId,
+					fallbackAccountId: cfg ? resolveDefaultWhatsAppAccountId(cfg) : DEFAULT_ACCOUNT_ID
 				})
 			};
 			return {
@@ -59,13 +64,13 @@ const whatsappApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter(
 			const verbose = getWhatsAppRuntime().logging.shouldLogVerbose();
 			await sendTypingWhatsApp(preparedTarget.to, {
 				cfg,
-				...preparedTarget.accountId ? { accountId: preparedTarget.accountId } : {}
+				accountId: preparedTarget.accountId
 			}).catch(() => {});
 			const result = await sendMessageWhatsApp(preparedTarget.to, pendingPayload.reactionPayload.text ?? "", {
 				cfg,
 				verbose,
-				preserveLeadingWhitespace: true,
-				...preparedTarget.accountId ? { accountId: preparedTarget.accountId } : {}
+				accountId: preparedTarget.accountId,
+				preserveLeadingWhitespace: true
 			});
 			if (!result.messageId) return null;
 			return {
@@ -80,8 +85,8 @@ const whatsappApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter(
 			await sendMessageWhatsApp(entry.to, payload.text, {
 				cfg,
 				verbose,
+				accountId: entry.accountId,
 				preserveLeadingWhitespace: true,
-				...entry.accountId ? { accountId: entry.accountId } : {},
 				quotedMessageKey: {
 					id: entry.messageId,
 					remoteJid: entry.remoteJid,
@@ -92,23 +97,24 @@ const whatsappApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter(
 	},
 	interactions: {
 		bindPending: ({ entry, request, view, pendingPayload }) => registerWhatsAppApprovalReactionTarget({
-			accountId: entry.accountId ?? "",
+			accountId: entry.accountId,
 			remoteJid: entry.remoteJid,
 			messageId: entry.messageId,
 			approvalId: request.id,
+			approvalKind: view.approvalKind,
 			allowedDecisions: pendingPayload.reactionPayload.allowedDecisions,
 			ttlMs: Math.max(1, view.expiresAtMs - Date.now())
 		}) ? true : null,
 		unbindPending: ({ entry }) => {
 			unregisterWhatsAppApprovalReactionTarget({
-				accountId: entry.accountId ?? "",
+				accountId: entry.accountId,
 				remoteJid: entry.remoteJid,
 				messageId: entry.messageId
 			});
 		},
 		cancelDelivered: ({ entry }) => {
 			unregisterWhatsAppApprovalReactionTarget({
-				accountId: entry.accountId ?? "",
+				accountId: entry.accountId,
 				remoteJid: entry.remoteJid,
 				messageId: entry.messageId
 			});

package/dist/approval-reactions-BGQoz25s.js

@@ -0,0 +1,373 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { t as getOptionalWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
+import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth } from "./group-session-key-CLTZeH_F.js";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { createApprovalReactionTargetStore, listApprovalReactionBindings, resolveTypedApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
+//#region extensions/whatsapp/src/approval-reactions.ts
+var approval_reactions_exports = /* @__PURE__ */ __exportAll({
+	clearWhatsAppApprovalReactionTargetsForTest: () => clearWhatsAppApprovalReactionTargetsForTest,
+	maybeResolveWhatsAppApprovalReaction: () => maybeResolveWhatsAppApprovalReaction,
+	prepareWhatsAppApprovalPayloadForDelivery: () => prepareWhatsAppApprovalPayloadForDelivery,
+	registerWhatsAppApprovalReactionTarget: () => registerWhatsAppApprovalReactionTarget,
+	registerWhatsAppApprovalReactionTargetForDeliveredPayload: () => registerWhatsAppApprovalReactionTargetForDeliveredPayload,
+	resolveWhatsAppApprovalReactionTargetWithPersistence: () => resolveWhatsAppApprovalReactionTargetWithPersistence,
+	unregisterWhatsAppApprovalReactionTarget: () => unregisterWhatsAppApprovalReactionTarget
+});
+const PERSISTENT_NAMESPACE = "whatsapp.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const DELIVERY_BINDING_CHANNEL_DATA_KEY = "whatsappApprovalReactionBindingV1";
+const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-DoeBBt22.js"));
+const whatsappApprovalReactionTargets = createApprovalReactionTargetStore({
+	namespace: PERSISTENT_NAMESPACE,
+	maxEntries: PERSISTENT_MAX_ENTRIES,
+	defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS,
+	openStore: (storeParams) => getOptionalWhatsAppRuntime()?.state.openKeyedStore(storeParams),
+	logPersistentError: reportPersistentApprovalReactionError,
+	readPersistedTarget
+});
+const loadApprovalResolver = resolverRuntimeLoader;
+function buildReactionTargetKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId) return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function addCandidateRemoteJid(target, value) {
+	const remoteJid = value?.trim();
+	if (remoteJid && !target.includes(remoteJid)) target.push(remoteJid);
+}
+function reportPersistentApprovalReactionError(error) {
+	try {
+		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
+			plugin: "whatsapp",
+			feature: "approval-reaction-state"
+		}).warn("WhatsApp persistent approval reaction state failed", { error: String(error) });
+	} catch {}
+}
+function reportApprovalBindingCorrelationMismatch(binding) {
+	try {
+		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
+			plugin: "whatsapp",
+			feature: "approval-reaction-state"
+		}).warn("WhatsApp approval prompt text failed binding correlation; reactions disabled", {
+			approvalId: binding.approvalId,
+			approvalKind: binding.approvalKind
+		});
+	} catch {}
+}
+function readPersistedTarget(target) {
+	const value = target;
+	if (!value || typeof value.approvalId !== "string" || !Array.isArray(value.allowedDecisions) || value.approvalKind !== "exec" && value.approvalKind !== "plugin") return null;
+	return {
+		approvalId: value.approvalId,
+		approvalKind: value.approvalKind,
+		allowedDecisions: value.allowedDecisions
+	};
+}
+function listWhatsAppApprovalReactionBindings(allowedDecisions) {
+	return listApprovalReactionBindings({ allowedDecisions });
+}
+const APPROVAL_ID_LINE_RE = /^\s*ID:\s*(\S(?:.*\S)?)\s*$/i;
+const APPROVAL_KIND_LINE_RE = /^\s*(?:\S+\s+)?(Exec|Plugin) approval required\s*$/i;
+function isApprovalDecision(value) {
+	return value === "allow-once" || value === "allow-always" || value === "deny";
+}
+function readStrictDecisionList(value) {
+	if (!Array.isArray(value) || value.length === 0 || !value.every(isApprovalDecision)) return null;
+	return new Set(value).size === value.length ? [...value] : null;
+}
+function readStrictApprovalMetadata(payload) {
+	const value = payload.channelData?.execApproval;
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const approvalId = record.approvalId;
+	const approvalKind = record.approvalKind;
+	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
+	if (typeof approvalId !== "string" || !approvalId || approvalId !== approvalId.trim() || approvalKind !== "exec" && approvalKind !== "plugin" || !allowedDecisions) return null;
+	return {
+		version: 1,
+		approvalId,
+		approvalKind,
+		allowedDecisions
+	};
+}
+function listTypedApprovalActions(presentation) {
+	return presentation.blocks.flatMap((block) => {
+		if (block.type === "buttons") return block.buttons.flatMap((button) => button.action?.type === "approval" ? [button.action] : []);
+		return [];
+	});
+}
+function decisionSetsMatch(left, right) {
+	return left.length === right.length && left.every((decision) => right.includes(decision));
+}
+function readTypedApprovalDeliveryBinding(params) {
+	const metadata = readStrictApprovalMetadata(params.payload);
+	if (!metadata) return null;
+	const actions = listTypedApprovalActions(params.presentation);
+	if (actions.length === 0 || actions.some((action) => action.approvalId !== metadata.approvalId || action.approvalKind !== metadata.approvalKind)) return null;
+	const actionDecisions = actions.map((action) => action.decision);
+	if (new Set(actionDecisions).size !== actionDecisions.length || !decisionSetsMatch(metadata.allowedDecisions, actionDecisions)) return null;
+	return metadata;
+}
+function visibleApprovalBindingMatches(text, binding) {
+	const lines = (text ?? "").split(/\r?\n/);
+	const kindMatches = lines.map((line) => line.match(APPROVAL_KIND_LINE_RE)).filter((match) => Boolean(match));
+	const idMatches = lines.map((line) => line.match(APPROVAL_ID_LINE_RE)).filter((match) => Boolean(match));
+	const visibleKind = kindMatches[0]?.[1]?.toLowerCase();
+	if (kindMatches.length !== 1 || idMatches.length !== 1 || visibleKind !== binding.approvalKind || idMatches[0]?.[1] !== binding.approvalId) return false;
+	const hintIndices = lines.flatMap((line, index) => line.trim().toLowerCase() === "react with:" ? [index] : []);
+	if (hintIndices.length !== 1) return false;
+	const hintIndex = hintIndices[0];
+	if (hintIndex === void 0) return false;
+	let cursor = hintIndex + 1;
+	while (cursor < lines.length && !lines[cursor]?.trim()) cursor += 1;
+	const decisionLines = [];
+	while (cursor < lines.length) {
+		const decisionLine = lines[cursor]?.trim();
+		if (!decisionLine) break;
+		decisionLines.push(decisionLine);
+		cursor += 1;
+	}
+	const knownBindings = listWhatsAppApprovalReactionBindings([
+		"allow-once",
+		"allow-always",
+		"deny"
+	]);
+	const visibleDecisions = decisionLines.map((line) => knownBindings.find((entry) => `${entry.emoji} ${entry.label}` === line)?.decision);
+	if (!visibleDecisions.every(isApprovalDecision)) return false;
+	return new Set(visibleDecisions).size === visibleDecisions.length && decisionSetsMatch(binding.allowedDecisions, visibleDecisions);
+}
+function readDeliveredApprovalBinding(payload) {
+	const metadata = readStrictApprovalMetadata(payload);
+	const value = payload.channelData?.[DELIVERY_BINDING_CHANNEL_DATA_KEY];
+	if (!metadata || !value || typeof value !== "object" || Array.isArray(value)) return null;
+	const record = value;
+	const allowedDecisions = readStrictDecisionList(record.allowedDecisions);
+	if (record.version !== 1 || record.approvalId !== metadata.approvalId || record.approvalKind !== metadata.approvalKind || !allowedDecisions || !decisionSetsMatch(metadata.allowedDecisions, allowedDecisions)) return null;
+	return metadata;
+}
+/** Preserve a validated typed approval binding until the platform message id is known. */
+function prepareWhatsAppApprovalPayloadForDelivery(params) {
+	const binding = readTypedApprovalDeliveryBinding(params);
+	if (!binding) return null;
+	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
+		reportApprovalBindingCorrelationMismatch(binding);
+		return null;
+	}
+	return {
+		...params.payload,
+		channelData: {
+			...params.payload.channelData,
+			[DELIVERY_BINDING_CHANNEL_DATA_KEY]: binding
+		}
+	};
+}
+function registerWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = listWhatsAppApprovalReactionBindings(params.allowedDecisions).map((binding) => binding.decision);
+	if (!key || !approvalId || params.approvalKind !== "exec" && params.approvalKind !== "plugin" || allowedDecisions.length === 0) return null;
+	const target = {
+		approvalId,
+		approvalKind: params.approvalKind,
+		allowedDecisions
+	};
+	whatsappApprovalReactionTargets.register(key, target, { ttlMs: params.ttlMs });
+	return target;
+}
+function listWhatsAppDeliveredMessageIdentities(results) {
+	const identities = [];
+	const seen = /* @__PURE__ */ new Set();
+	const add = (params) => {
+		if (params.channel && params.channel !== "whatsapp") return;
+		const messageId = params.messageId?.trim() ?? "";
+		const remoteJid = params.toJid?.trim() ?? "";
+		const key = `${remoteJid}:${messageId}`;
+		if (!messageId || messageId === "unknown" || !remoteJid || seen.has(key)) return;
+		seen.add(key);
+		identities.push({
+			messageId,
+			remoteJid
+		});
+	};
+	for (const result of results) {
+		if (result.channel !== "whatsapp") continue;
+		add(result);
+		for (const raw of result.receipt?.raw ?? []) add(raw);
+		for (const part of result.receipt?.parts ?? []) add({
+			channel: part.raw?.channel,
+			messageId: part.raw?.messageId ?? part.platformMessageId,
+			toJid: part.raw?.toJid
+		});
+	}
+	return identities;
+}
+/** Bind generic forwarded approvals to the exact WhatsApp messages accepted by Baileys. */
+function registerWhatsAppApprovalReactionTargetForDeliveredPayload(params) {
+	if (params.target.channel.trim().toLowerCase() !== "whatsapp") return false;
+	const binding = readDeliveredApprovalBinding(params.payload);
+	if (!binding) return false;
+	if (!visibleApprovalBindingMatches(params.payload.text, binding)) {
+		reportApprovalBindingCorrelationMismatch(binding);
+		return false;
+	}
+	const accountId = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.target.accountId
+	}).accountId;
+	let registered = false;
+	for (const { messageId, remoteJid } of listWhatsAppDeliveredMessageIdentities(params.results)) registered = Boolean(registerWhatsAppApprovalReactionTarget({
+		accountId,
+		remoteJid,
+		messageId,
+		approvalId: binding.approvalId,
+		approvalKind: binding.approvalKind,
+		allowedDecisions: binding.allowedDecisions,
+		ttlMs: params.ttlMs
+	})) || registered;
+	return registered;
+}
+function unregisterWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return;
+	whatsappApprovalReactionTargets.delete(key);
+}
+function resolveTarget(params) {
+	const resolved = resolveTypedApprovalReactionTarget({
+		target: params.target,
+		reactionKey: params.reactionKey
+	});
+	return resolved ? {
+		approvalId: resolved.approvalId,
+		approvalKind: resolved.approvalKind,
+		decision: resolved.decision
+	} : null;
+}
+async function resolveWhatsAppApprovalReactionTargetWithPersistence(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return null;
+	return resolveTarget({
+		target: await whatsappApprovalReactionTargets.lookup(key),
+		reactionKey: params.reactionKey
+	});
+}
+async function resolveWhatsAppApprovalReactionTargetFromCandidates(params) {
+	const candidateRemoteJids = [];
+	for (const observedRemoteJid of params.observedRemoteJids) {
+		addCandidateRemoteJid(candidateRemoteJids, observedRemoteJid);
+		try {
+			for (const candidate of await params.resolveReactionTargetJids?.(observedRemoteJid) ?? []) addCandidateRemoteJid(candidateRemoteJids, candidate);
+		} catch (error) {
+			params.logVerboseMessage?.(`whatsapp: approval reaction target JID mapping failed for ${observedRemoteJid}: ${String(error)}`);
+		}
+	}
+	for (const remoteJid of candidateRemoteJids) {
+		const target = await resolveWhatsAppApprovalReactionTargetWithPersistence({
+			accountId: params.accountId,
+			remoteJid,
+			messageId: params.messageId,
+			reactionKey: params.reactionKey
+		});
+		if (target) return {
+			...target,
+			remoteJid
+		};
+	}
+	return null;
+}
+function readWhatsAppApprovalReactionEvent(params) {
+	const msg = params.msg;
+	const reaction = msg.message?.reactionMessage;
+	const reactionKey = reaction?.text?.trim() ?? "";
+	const messageId = reaction?.key?.id?.trim() ?? "";
+	const remoteJids = [];
+	addCandidateRemoteJid(remoteJids, reaction?.key?.remoteJid);
+	addCandidateRemoteJid(remoteJids, msg.key?.remoteJid);
+	const actorJid = msg.key?.participant?.trim() || (msg.key?.fromMe ? params.selfLid?.trim() ?? params.selfJid?.trim() ?? "" : msg.key?.remoteJid?.trim() ?? "");
+	if (!reactionKey || !messageId || remoteJids.length === 0 || !actorJid) return null;
+	return {
+		remoteJids,
+		messageId,
+		actorJid,
+		reactionKey
+	};
+}
+async function maybeResolveWhatsAppApprovalReaction(params) {
+	const event = readWhatsAppApprovalReactionEvent({
+		msg: params.msg,
+		selfJid: params.selfJid,
+		selfLid: params.selfLid
+	});
+	if (!event) return false;
+	const target = await resolveWhatsAppApprovalReactionTargetFromCandidates({
+		accountId: params.accountId,
+		observedRemoteJids: event.remoteJids,
+		messageId: event.messageId,
+		reactionKey: event.reactionKey,
+		resolveReactionTargetJids: params.resolveReactionTargetJids,
+		logVerboseMessage: params.logVerboseMessage
+	});
+	if (!target) return false;
+	const actorId = await params.resolveInboundJid(event.actorJid);
+	if (!actorId) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction ignored for ${target.approvalId}; missing actor identity`);
+		return true;
+	}
+	if (getWhatsAppApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).length === 0) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId}; reactions require explicit approvers`);
+		return true;
+	}
+	if (!whatsappApprovalAuth.authorizeActorAction({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		senderId: actorId,
+		action: "approve",
+		approvalKind: target.approvalKind
+	}).authorized) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId} sender=${actorId}`);
+		return true;
+	}
+	const { isApprovalNotFoundError, resolveWhatsAppApproval } = await loadApprovalResolver();
+	try {
+		const result = await resolveWhatsAppApproval({
+			cfg: params.cfg,
+			approvalId: target.approvalId,
+			approvalKind: target.approvalKind,
+			decision: target.decision,
+			senderId: actorId,
+			gatewayUrl: params.gatewayUrl
+		});
+		unregisterWhatsAppApprovalReactionTarget({
+			accountId: params.accountId,
+			remoteJid: target.remoteJid,
+			messageId: event.messageId
+		});
+		const canonicalDecision = "decision" in result.approval ? ` decision=${result.approval.decision}` : "";
+		params.logVerboseMessage?.(result.applied ? `whatsapp: approval reaction applied id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}` : `whatsapp: approval reaction already resolved id=${target.approvalId} sender=${actorId} status=${result.approval.status}${canonicalDecision}`);
+		return true;
+	} catch (error) {
+		if (isApprovalNotFoundError(error)) {
+			unregisterWhatsAppApprovalReactionTarget({
+				accountId: params.accountId,
+				remoteJid: target.remoteJid,
+				messageId: event.messageId
+			});
+			params.logVerboseMessage?.(`whatsapp: approval reaction ignored for expired approval id=${target.approvalId} sender=${actorId}`);
+			return true;
+		}
+		params.logVerboseMessage?.(`whatsapp: approval reaction failed id=${target.approvalId} sender=${actorId}: ${String(error)}`);
+		return true;
+	}
+}
+function clearWhatsAppApprovalReactionTargetsForTest() {
+	whatsappApprovalReactionTargets.clearForTest();
+	resolverRuntimeLoader.clear();
+}
+//#endregion
+export { unregisterWhatsAppApprovalReactionTarget as i, maybeResolveWhatsAppApprovalReaction as n, registerWhatsAppApprovalReactionTarget as r, approval_reactions_exports as t };

package/dist/{approval-resolver-DF-lu8k5.js → approval-resolver-DoeBBt22.js}

@@ -2,9 +2,10 @@ import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveApprovalOverGateway } from "openclaw/plugin-sdk/approval-gateway-runtime";
 //#region extensions/whatsapp/src/approval-resolver.ts
 async function resolveWhatsAppApproval(params) {
-	await resolveApprovalOverGateway({
+	return await resolveApprovalOverGateway({
 		cfg: params.cfg,
 		approvalId: params.approvalId,
+		approvalKind: params.approvalKind,
 		decision: params.decision,
 		senderId: params.senderId,
 		gatewayUrl: params.gatewayUrl,