@openclaw/whatsapp 2026.5.22 → 2026.5.24-beta.2

package/dist/{channel-BQqQ-Gp5.js → channel-DOxZCBxE.js}

@@ -1,50 +1,431 @@
-import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
+import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { a as resolveWhatsAppAccount } from "./accounts-BPYgj8Fv.js";
 import { c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, n as isWhatsAppNewsletterJid, o as normalizeWhatsAppAllowFromEntry, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.js";
 import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-CV-iBmSG.js";
 import { t as resolveWhatsAppReactionLevel } from "./reaction-level-BqMOEBeq.js";
-import { r as normalizeWhatsAppPayloadTextPreservingIndentation } from "./outbound-media-contract-ioTkt8tn.js";
 import "./normalize-Bxwqo-bW.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, t as sendMessageWhatsApp } from "./send-E_kMiuZP.js";
+import { d as getWhatsAppApprovalApprovers, f as whatsappApprovalAuth, i as sendTypingWhatsApp, n as sendPollWhatsApp, o as addWhatsAppApprovalReactionHintToText, t as sendMessageWhatsApp } from "./send-C9jEw6hx.js";
+import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
+import { r as normalizeWhatsAppPayloadTextPreservingIndentation } from "./outbound-media-contract-ioTkt8tn.js";
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-BDzvb3ee.js";
 import { t as createWhatsAppOutboundBase } from "./outbound-base-E84SMkd9.js";
-import { t as getWhatsAppRuntime } from "./runtime-CboC4QhQ.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import { a as resolveWhatsAppGroupRequireMention, c as resolveWhatsAppMentionStripRegexes, i as whatsappSetupWizardProxy, l as formatWhatsAppConfigAllowFromEntries, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, r as loadWhatsAppChannelRuntime, s as resolveWhatsAppGroupIntroHint, t as whatsappSetupAdapter } from "./setup-core-BTDKEc-x.js";
-import { f as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-GTQvJznL.js";
+import { a as resolveWhatsAppGroupRequireMention, c as resolveWhatsAppMentionStripRegexes, i as whatsappSetupWizardProxy, l as formatWhatsAppConfigAllowFromEntries, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, r as loadWhatsAppChannelRuntime, s as resolveWhatsAppGroupIntroHint, t as whatsappSetupAdapter } from "./setup-core-Ce-b_wzQ.js";
+import { f as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BrKb0mwT.js";
 import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-D_BmQUR9.js";
 import { createActionGate as createActionGate$1 } from "openclaw/plugin-sdk/channel-actions";
-import { asString, collectIssuesForEnabledAccounts, createAsyncComputedAccountStatusAdapter, createDefaultChannelRuntimeState, isRecord } from "openclaw/plugin-sdk/status-helpers";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asString, collectIssuesForEnabledAccounts, createAsyncComputedAccountStatusAdapter, createDefaultChannelRuntimeState, isRecord as isRecord$1 } from "openclaw/plugin-sdk/status-helpers";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/core";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildDmGroupAccountAllowlistAdapter } from "openclaw/plugin-sdk/allowlist-config-edit";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/channel-core";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
+import { createChannelApprovalCapability, splitChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, doesApprovalRequestMatchChannelAccount, resolveApprovalRequestSessionTarget } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildExecApprovalPendingReplyPayload, buildPluginApprovalPendingReplyPayload, resolveExecApprovalCommandDisplay, resolveExecApprovalRequestAllowedDecisions } from "openclaw/plugin-sdk/approval-runtime";
+import { channelRouteTargetsMatchExact } from "openclaw/plugin-sdk/channel-route";
+import { normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/routing";
 import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-message";
 import { chunkText } from "openclaw/plugin-sdk/reply-chunking";
-//#region extensions/whatsapp/src/approval-auth.ts
-function normalizeWhatsAppApproverId(value) {
-	const normalized = normalizeWhatsAppTarget(String(value));
-	if (!normalized || normalized.endsWith("@g.us")) return;
-	return normalized;
-}
-const whatsappApprovalAuth = createResolvedApproverActionAuthAdapter({
-	channelLabel: "WhatsApp",
-	resolveApprovers: ({ cfg, accountId }) => {
-		const account = resolveWhatsAppAccount({
-			cfg,
-			accountId
-		});
-		return resolveApprovalApprovers({
-			allowFrom: account.allowFrom,
-			defaultTo: account.defaultTo,
-			normalizeApprover: normalizeWhatsAppApproverId
+//#region extensions/whatsapp/src/approval-native.ts
+const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
+const DEFAULT_PLUGIN_APPROVAL_DECISIONS = [
+	"allow-once",
+	"allow-always",
+	"deny"
+];
+function isWhatsAppApprovalTransportEnabled(params) {
+	return resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).enabled;
+}
+function resolveApprovalKind(request, approvalKind) {
+	if (approvalKind) return approvalKind;
+	return "command" in request.request ? "exec" : "plugin";
+}
+function resolveApprovalForwardingConfig(params) {
+	return params.approvalKind === "plugin" ? params.cfg.approvals?.plugin : params.cfg.approvals?.exec;
+}
+function normalizeApprovalForwardingMode(mode) {
+	return mode ?? DEFAULT_APPROVAL_FORWARDING_MODE;
+}
+function approvalModeIncludesSession(mode) {
+	return mode === "session" || mode === "both";
+}
+function approvalModeIncludesTargets(mode) {
+	return mode === "targets" || mode === "both";
+}
+function matchesForwardingFilters(params) {
+	return matchesApprovalRequestFilters({
+		request: params.request.request,
+		agentFilter: params.config.agentFilter,
+		sessionFilter: params.config.sessionFilter,
+		fallbackAgentIdFromSessionKey: true
+	});
+}
+function targetAccountMatchesWhatsAppAccount(params) {
+	const targetAccountId = normalizeOptionalString(params.targetAccountId);
+	const accountId = normalizeOptionalString(params.accountId);
+	if (targetAccountId) return !accountId || normalizeAccountId$1(targetAccountId) === normalizeAccountId$1(accountId);
+	if (!accountId) return true;
+	const normalizedAccountId = normalizeAccountId$1(accountId);
+	if (normalizedAccountId === normalizeAccountId$1(resolveDefaultWhatsAppAccountId(params.cfg))) return true;
+	const enabledAccountIds = listAccountIds(params.cfg).filter((candidateAccountId) => isWhatsAppApprovalTransportEnabled({
+		cfg: params.cfg,
+		accountId: candidateAccountId
+	})).map((candidateAccountId) => normalizeAccountId$1(candidateAccountId));
+	return enabledAccountIds.length === 1 && enabledAccountIds[0] === normalizedAccountId;
+}
+function normalizeWhatsAppForwardTarget(target) {
+	if (normalizeLowercaseStringOrEmpty(target.channel) !== "whatsapp") return null;
+	const to = normalizeWhatsAppMessagingTarget(target.to);
+	if (!to) return null;
+	return {
+		to,
+		accountId: normalizeOptionalString(target.accountId),
+		threadId: target.threadId ?? null
+	};
+}
+function nativeApprovalTargetsMatch(params) {
+	return channelRouteTargetsMatchExact({
+		left: {
+			channel: "whatsapp",
+			to: params.left.to,
+			accountId: params.left.accountId,
+			threadId: params.left.threadId
+		},
+		right: {
+			channel: "whatsapp",
+			to: params.right.to,
+			accountId: params.right.accountId,
+			threadId: params.right.threadId
+		}
+	});
+}
+function hasMatchingWhatsAppTarget(params) {
+	const candidateTarget = params.target ? normalizeWhatsAppForwardTarget(params.target) : null;
+	return (params.config.targets ?? []).some((target) => {
+		const configuredTarget = normalizeWhatsAppForwardTarget(target);
+		if (!configuredTarget) return false;
+		if (!targetAccountMatchesWhatsAppAccount({
+			cfg: params.cfg,
+			targetAccountId: configuredTarget.accountId,
+			accountId: params.accountId
+		})) return false;
+		if (!candidateTarget) return true;
+		return nativeApprovalTargetsMatch({
+			left: configuredTarget,
+			right: candidateTarget
 		});
+	});
+}
+function hasWhatsAppOriginOrSessionTarget(params) {
+	if (resolveTurnSourceWhatsAppOriginTarget(params.request)) return true;
+	const sessionTarget = resolveApprovalRequestSessionTarget({
+		cfg: params.cfg,
+		request: params.request
+	});
+	return normalizeLowercaseStringOrEmpty(sessionTarget?.channel) === "whatsapp" && targetAccountMatchesWhatsAppAccount({
+		cfg: params.cfg,
+		targetAccountId: sessionTarget?.accountId,
+		accountId: params.accountId
+	});
+}
+function canApprovalPotentiallyRouteToWhatsApp(params) {
+	if (!isWhatsAppApprovalTransportEnabled(params)) return false;
+	const config = resolveApprovalForwardingConfig(params);
+	if (!config?.enabled) return false;
+	const mode = normalizeApprovalForwardingMode(config.mode);
+	if (approvalModeIncludesSession(mode)) return true;
+	if (params.nativeSessionOnly) return false;
+	return approvalModeIncludesTargets(mode) && hasMatchingWhatsAppTarget({
+		cfg: params.cfg,
+		config,
+		accountId: params.accountId
+	});
+}
+function canAnyApprovalPotentiallyRouteToWhatsApp(params) {
+	return canApprovalPotentiallyRouteToWhatsApp({
+		...params,
+		approvalKind: "exec"
+	}) || canApprovalPotentiallyRouteToWhatsApp({
+		...params,
+		approvalKind: "plugin"
+	});
+}
+function isWhatsAppSessionApprovalEligible(params) {
+	if (!isWhatsAppApprovalTransportEnabled(params)) return false;
+	const config = resolveApprovalForwardingConfig(params);
+	if (!config?.enabled) return false;
+	if (!approvalModeIncludesSession(normalizeApprovalForwardingMode(config.mode))) return false;
+	if (!matchesForwardingFilters({
+		config,
+		request: params.request
+	})) return false;
+	if (!doesApprovalRequestMatchChannelAccount({
+		cfg: params.cfg,
+		request: params.request,
+		channel: "whatsapp",
+		accountId: params.accountId
+	})) return false;
+	return hasWhatsAppOriginOrSessionTarget({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		request: params.request
+	});
+}
+function isWhatsAppExplicitTargetEligible(params) {
+	if (!isWhatsAppApprovalTransportEnabled(params)) return false;
+	const config = resolveApprovalForwardingConfig(params);
+	if (!config?.enabled) return false;
+	if (!approvalModeIncludesTargets(normalizeApprovalForwardingMode(config.mode))) return false;
+	if (!matchesForwardingFilters({
+		config,
+		request: params.request
+	})) return false;
+	return hasMatchingWhatsAppTarget({
+		cfg: params.cfg,
+		config,
+		accountId: params.accountId,
+		target: params.target
+	});
+}
+function resolveTurnSourceWhatsAppOriginTarget(request) {
+	if (normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel) !== "whatsapp") return null;
+	const to = normalizeWhatsAppMessagingTarget(request.request.turnSourceTo ?? "");
+	if (!to) return null;
+	return {
+		to,
+		accountId: normalizeOptionalString(request.request.turnSourceAccountId)
+	};
+}
+function resolveSessionWhatsAppOriginTarget(sessionTarget) {
+	const to = normalizeWhatsAppMessagingTarget(sessionTarget.to);
+	return to ? {
+		to,
+		accountId: normalizeOptionalString(sessionTarget.accountId)
+	} : null;
+}
+function shouldHandleWhatsAppApprovalRequest(params) {
+	return isWhatsAppSessionApprovalEligible({
+		...params,
+		approvalKind: resolveApprovalKind(params.request, params.approvalKind)
+	});
+}
+const resolveWhatsAppOriginTargetBase = createChannelNativeOriginTargetResolver({
+	channel: "whatsapp",
+	shouldHandleRequest: shouldHandleWhatsAppApprovalRequest,
+	resolveTurnSourceTarget: resolveTurnSourceWhatsAppOriginTarget,
+	resolveSessionTarget: resolveSessionWhatsAppOriginTarget,
+	normalizeTarget: (target) => {
+		const to = normalizeWhatsAppMessagingTarget(target.to);
+		return to ? {
+			...target,
+			to
+		} : null;
+	}
+});
+function resolveWhatsAppOriginTarget(params) {
+	const target = resolveWhatsAppOriginTargetBase(params);
+	if (!target) return null;
+	if (isWhatsAppGroupJid(target.to) && getWhatsAppApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).length === 0) return null;
+	return target;
+}
+const resolveWhatsAppApproverDmTargets = createChannelApproverDmTargetResolver({
+	shouldHandleRequest: shouldHandleWhatsAppApprovalRequest,
+	resolveApprovers: getWhatsAppApprovalApprovers,
+	mapApprover: (approver, params) => {
+		const to = normalizeWhatsAppMessagingTarget(approver);
+		if (!to) return null;
+		return {
+			to,
+			accountId: normalizeOptionalString(params.accountId)
+		};
+	}
+});
+function appendWhatsAppReactionHint(params) {
+	return addWhatsAppApprovalReactionHintToText({
+		text: params.text ?? "",
+		allowedDecisions: params.allowedDecisions
+	});
+}
+function replaceApprovalIdPlaceholder(text, approvalId) {
+	return (text ?? "").replace(/\/approve\s+<id>/g, `/approve ${approvalId}`);
+}
+function buildWhatsAppExecPendingPayload(params) {
+	const allowedDecisions = resolveExecApprovalRequestAllowedDecisions(params.request.request);
+	const command = resolveExecApprovalCommandDisplay(params.request.request).commandText;
+	const payload = buildExecApprovalPendingReplyPayload({
+		approvalId: params.request.id,
+		approvalSlug: params.request.id.slice(0, 8),
+		approvalCommandId: params.request.id,
+		warningText: params.request.request.warningText ?? void 0,
+		ask: params.request.request.ask ?? null,
+		agentId: params.request.request.agentId ?? null,
+		allowedDecisions,
+		command,
+		cwd: params.request.request.cwd ?? void 0,
+		host: params.request.request.host === "node" ? "node" : "gateway",
+		nodeId: params.request.request.nodeId ?? void 0,
+		sessionKey: params.request.request.sessionKey ?? null,
+		expiresAtMs: params.request.expiresAtMs,
+		nowMs: params.nowMs
+	});
+	return {
+		...payload,
+		text: appendWhatsAppReactionHint({
+			text: replaceApprovalIdPlaceholder(payload.text, params.request.id),
+			allowedDecisions
+		})
+	};
+}
+function buildWhatsAppPluginPendingPayload(params) {
+	const configuredDecisions = params.request.request.allowedDecisions;
+	const allowedDecisions = configuredDecisions && configuredDecisions.length > 0 ? configuredDecisions : DEFAULT_PLUGIN_APPROVAL_DECISIONS;
+	const payload = buildPluginApprovalPendingReplyPayload({
+		request: params.request,
+		nowMs: params.nowMs,
+		allowedDecisions
+	});
+	return {
+		...payload,
+		text: appendWhatsAppReactionHint({
+			text: replaceApprovalIdPlaceholder(payload.text, params.request.id),
+			allowedDecisions
+		})
+	};
+}
+const whatsappApprovalCapability = createChannelApprovalCapability({
+	...whatsappApprovalAuth,
+	getActionAvailabilityState: ({ cfg, accountId, approvalKind }) => (approvalKind ? canApprovalPotentiallyRouteToWhatsApp({
+		cfg,
+		accountId,
+		approvalKind
+	}) : canAnyApprovalPotentiallyRouteToWhatsApp({
+		cfg,
+		accountId
+	})) ? { kind: "enabled" } : { kind: "disabled" },
+	getExecInitiatingSurfaceState: ({ cfg, accountId }) => canApprovalPotentiallyRouteToWhatsApp({
+		cfg,
+		accountId,
+		approvalKind: "exec"
+	}) ? { kind: "enabled" } : { kind: "disabled" },
+	describeExecApprovalSetup: ({ accountId }) => {
+		return `WhatsApp supports native exec approvals for this account when \`approvals.exec.enabled\` is true and the route allows WhatsApp. Link WhatsApp and keep the gateway running; configure \`${accountId && accountId !== "default" ? `channels.whatsapp.accounts.${accountId}` : "channels.whatsapp"}.allowFrom\` to restrict approvers.`;
 	},
-	normalizeSenderId: (value) => normalizeWhatsAppApproverId(value)
+	delivery: {
+		hasConfiguredDmRoute: ({ cfg }) => listAccountIds(cfg).some((accountId) => {
+			if (!canAnyApprovalPotentiallyRouteToWhatsApp({
+				cfg,
+				accountId,
+				nativeSessionOnly: true
+			})) return false;
+			return getWhatsAppApprovalApprovers({
+				cfg,
+				accountId
+			}).length > 0;
+		}),
+		shouldSuppressForwardingFallback: ({ cfg, approvalKind, target, request }) => {
+			const forwardingTarget = normalizeWhatsAppForwardTarget(target);
+			if (!forwardingTarget) return false;
+			const accountId = forwardingTarget.accountId ?? normalizeOptionalString(request.request.turnSourceAccountId);
+			const forwardingTargetForMatch = {
+				...forwardingTarget,
+				accountId
+			};
+			const kind = resolveApprovalKind(request, approvalKind);
+			if (!(target.source === "target" ? isWhatsAppExplicitTargetEligible({
+				cfg,
+				accountId,
+				approvalKind: kind,
+				request,
+				target
+			}) : isWhatsAppSessionApprovalEligible({
+				cfg,
+				accountId,
+				approvalKind: kind,
+				request
+			}))) return false;
+			const originTarget = resolveWhatsAppOriginTarget({
+				cfg,
+				accountId,
+				approvalKind: kind,
+				request
+			});
+			if (originTarget && nativeApprovalTargetsMatch({
+				left: forwardingTargetForMatch,
+				right: originTarget
+			})) return true;
+			return resolveWhatsAppApproverDmTargets({
+				cfg,
+				accountId,
+				approvalKind: kind,
+				request
+			}).some((approverTarget) => nativeApprovalTargetsMatch({
+				left: forwardingTargetForMatch,
+				right: approverTarget
+			}));
+		}
+	},
+	render: {
+		exec: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppExecPendingPayload({
+			request,
+			nowMs
+		}) },
+		plugin: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppPluginPendingPayload({
+			request,
+			nowMs
+		}) }
+	},
+	native: {
+		describeDeliveryCapabilities: ({ cfg, accountId, approvalKind, request }) => {
+			const originTarget = resolveWhatsAppOriginTarget({
+				cfg,
+				accountId,
+				approvalKind,
+				request
+			});
+			const approverTargets = resolveWhatsAppApproverDmTargets({
+				cfg,
+				accountId,
+				approvalKind,
+				request
+			});
+			return {
+				enabled: Boolean(originTarget) || approverTargets.length > 0,
+				preferredSurface: originTarget ? "origin" : "approver-dm",
+				supportsOriginSurface: Boolean(originTarget),
+				supportsApproverDmSurface: approverTargets.length > 0,
+				notifyOriginWhenDmOnly: true
+			};
+		},
+		resolveOriginTarget: resolveWhatsAppOriginTarget,
+		resolveApproverDmTargets: resolveWhatsAppApproverDmTargets
+	},
+	nativeRuntime: createLazyChannelApprovalNativeRuntimeAdapter({
+		eventKinds: ["exec", "plugin"],
+		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && canAnyApprovalPotentiallyRouteToWhatsApp({
+			cfg,
+			accountId,
+			nativeSessionOnly: true
+		}),
+		shouldHandle: ({ cfg, accountId, context, request }) => Boolean(context) && shouldHandleWhatsAppApprovalRequest({
+			cfg,
+			accountId,
+			request
+		}),
+		load: async () => (await import("./approval-handler.runtime-j8U6lgcp.js")).whatsappApprovalNativeRuntime
+	})
 });
+splitChannelApprovalCapability(whatsappApprovalCapability);
 //#endregion
 //#region extensions/whatsapp/src/channel-actions.ts
 function areWhatsAppAgentReactionsEnabled(params) {
@@ -201,7 +582,7 @@ function resolveWhatsAppOutboundSessionRoute(params) {
 //#region extensions/whatsapp/src/status-issues.ts
 const RECENT_DISCONNECT_WARNING_WINDOW_MS = 900 * 1e3;
 function readWhatsAppAccountStatus(value) {
-	if (!isRecord(value)) return null;
+	if (!isRecord$1(value)) return null;
 	return {
 		accountId: value.accountId,
 		statusState: value.statusState,
@@ -224,7 +605,7 @@ function readLastDisconnect(value) {
 			error
 		} : null;
 	}
-	if (!isRecord(value)) return null;
+	if (!isRecord$1(value)) return null;
 	return {
 		at: typeof value.at === "number" ? value.at : null,
 		error: asString(value.error)
@@ -323,8 +704,8 @@ function collectWhatsAppStatusIssues(accounts) {
 //#endregion
 //#region extensions/whatsapp/src/channel.ts
 const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-CfLFAK54.js").then((n) => n.t));
-const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-CHdR3gbn.js"));
-function parseWhatsAppExplicitTarget(raw) {
+const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-O7asbQQ1.js"));
+function resolveWhatsAppTargetInfo(raw) {
 	const normalized = normalizeWhatsAppTarget(raw);
 	if (!normalized) return null;
 	return {
@@ -384,8 +765,7 @@ const whatsappPlugin = createChatChannelPlugin({
 			targetPrefixes: ["whatsapp"],
 			normalizeTarget: normalizeWhatsAppMessagingTarget,
 			resolveOutboundSessionRoute: (params) => resolveWhatsAppOutboundSessionRoute(params),
-			parseExplicitTarget: ({ raw }) => parseWhatsAppExplicitTarget(raw),
-			inferTargetChatType: ({ to }) => parseWhatsAppExplicitTarget(to)?.chatType,
+			inferTargetChatType: ({ to }) => resolveWhatsAppTargetInfo(to)?.chatType,
 			targetResolver: {
 				looksLikeId: looksLikeWhatsAppTargetId,
 				hint: "<E.164|group JID|newsletter JID>"
@@ -433,7 +813,7 @@ const whatsappPlugin = createChatChannelPlugin({
 				toolContext
 			})
 		},
-		approvalCapability: whatsappApprovalAuth,
+		approvalCapability: whatsappApprovalCapability,
 		auth: { login: async ({ cfg, accountId, runtime, verbose }) => {
 			const resolvedAccountId = accountId?.trim() || whatsappPlugin.config.defaultAccountId?.(cfg) || DEFAULT_ACCOUNT_ID;
 			await (await loadWhatsAppChannelRuntime()).loginWeb(Boolean(verbose), void 0, runtime, resolvedAccountId);
@@ -543,7 +923,8 @@ const whatsappPlugin = createChatChannelPlugin({
 						accountId: ctx.accountId,
 						...next
 					}),
-					accountId: account.accountId
+					accountId: account.accountId,
+					channelRuntime: ctx.channelRuntime
 				});
 			},
 			loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => await (await loadWhatsAppChannelRuntime()).startWebLoginWithQr({

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as whatsappPlugin } from "./channel-BQqQ-Gp5.js";
+import { t as whatsappPlugin } from "./channel-DOxZCBxE.js";
 export { whatsappPlugin };

package/dist/{channel-react-action-CHdR3gbn.js → channel-react-action-O7asbQQ1.js}

@@ -1,8 +1,8 @@
 import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BPYgj8Fv.js";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.js";
-import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-D4UqEXqf.js";
+import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-DGx8vCsS.js";
 import "./normalize-Bxwqo-bW.js";
-import { t as sendMessageWhatsApp } from "./send-E_kMiuZP.js";
+import { t as sendMessageWhatsApp } from "./send-C9jEw6hx.js";
 import { jsonResult, readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 //#region extensions/whatsapp/src/channel-react-action.ts
 const WHATSAPP_CHANNEL = "whatsapp";

package/dist/{channel.runtime-BZ_ya3mR.js → channel.runtime-B0cFknwD.js}

@@ -1,9 +1,9 @@
 import { startWebLoginWithQr as startWebLoginWithQr$1, waitForWebLogin as waitForWebLogin$1 } from "./login-qr-runtime.js";
-import { c as logoutWeb$1, d as readWebAuthExistsBestEffort$1, f as readWebAuthExistsForDecision$1, g as readWebSelfId$1, h as readWebAuthState$1, m as readWebAuthSnapshotBestEffort$1, o as getWebAuthAgeMs$1, p as readWebAuthSnapshot$1, s as logWebSelfId$1, x as webAuthExists$1 } from "./auth-store-GTQvJznL.js";
+import { c as logoutWeb$1, d as readWebAuthExistsBestEffort$1, f as readWebAuthExistsForDecision$1, g as readWebSelfId$1, h as readWebAuthState$1, m as readWebAuthSnapshotBestEffort$1, o as getWebAuthAgeMs$1, p as readWebAuthSnapshot$1, s as logWebSelfId$1, x as webAuthExists$1 } from "./auth-store-BrKb0mwT.js";
 import { t as getActiveWebListener$1 } from "./active-listener-B4SDebQ6.js";
-import { t as monitorWebChannel$1 } from "./monitor-ClhD-fQ6.js";
-import { t as loginWeb$1 } from "./login-nJwaNuC-.js";
-import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-Uoh9W_29.js";
+import { t as monitorWebChannel$1 } from "./monitor-BU1ydkuF.js";
+import { t as loginWeb$1 } from "./login-BEkrpJbZ.js";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-CAchPwW5.js";
 //#region extensions/whatsapp/src/channel.runtime.ts
 function getActiveWebListener(...args) {
 	return getActiveWebListener$1(...args);

package/dist/{channel.setup-vWI0fm8Y.js → channel.setup-Bk7Hmp4a.js}

@@ -1,8 +1,8 @@
-import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, s as resolveWhatsAppGroupIntroHint, t as whatsappSetupAdapter } from "./setup-core-BTDKEc-x.js";
+import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, s as resolveWhatsAppGroupIntroHint, t as whatsappSetupAdapter } from "./setup-core-Ce-b_wzQ.js";
 import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-D_BmQUR9.js";
 //#region extensions/whatsapp/src/channel.setup.ts
 async function isWhatsAppAuthConfigured(account) {
-	const { readWebAuthState } = await import("./auth-store-GTQvJznL.js").then((n) => n.i);
+	const { readWebAuthState } = await import("./auth-store-BrKb0mwT.js").then((n) => n.i);
 	return await readWebAuthState(account.authDir) === "linked";
 }
 const whatsappSetupPlugin = {

package/dist/{connection-controller-9TXWZRhx.js → connection-controller-ja6z4F_k.js}

@@ -1,7 +1,7 @@
 import { n as registerWhatsAppConnectionController, r as unregisterWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
-import { c as logoutWeb } from "./auth-store-GTQvJznL.js";
-import { r as waitForWaConnection, t as createWaSocket } from "./session-CPsgRMMa.js";
+import { c as logoutWeb } from "./auth-store-BrKb0mwT.js";
+import { r as waitForWaConnection, t as createWaSocket } from "./session-CDgpDc0l.js";
 import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { clamp } from "openclaw/plugin-sdk/text-utility-runtime";
 import { DisconnectReason } from "baileys";

package/dist/light-runtime-api.js

@@ -1,5 +1,5 @@
 import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-BDzvb3ee.js";
-import { c as logoutWeb, g as readWebSelfId, l as pickWebChannel, o as getWebAuthAgeMs, s as logWebSelfId, t as WA_WEB_AUTH_DIR, x as webAuthExists } from "./auth-store-GTQvJznL.js";
+import { c as logoutWeb, g as readWebSelfId, l as pickWebChannel, o as getWebAuthAgeMs, s as logWebSelfId, t as WA_WEB_AUTH_DIR, x as webAuthExists } from "./auth-store-BrKb0mwT.js";
 import { t as getActiveWebListener } from "./active-listener-B4SDebQ6.js";
 export { WA_WEB_AUTH_DIR, createWhatsAppLoginTool, formatError, getActiveWebListener, getStatusCode, getWebAuthAgeMs, logWebSelfId, logoutWeb, pickWebChannel, readWebSelfId, webAuthExists };

package/dist/{login-nJwaNuC-.js → login-BEkrpJbZ.js}

@@ -1,8 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
 import { a as resolveWhatsAppAccount } from "./accounts-BPYgj8Fv.js";
-import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-GTQvJznL.js";
-import { a as renderQrTerminal, i as resolveWhatsAppSocketTiming, t as createWaSocket } from "./session-CPsgRMMa.js";
-import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-9TXWZRhx.js";
+import { b as restoreCredsFromBackupIfNeeded } from "./auth-store-BrKb0mwT.js";
+import { a as renderQrTerminal, i as resolveWhatsAppSocketTiming, t as createWaSocket } from "./session-CDgpDc0l.js";
+import { a as closeWaSocketSoon, o as waitForWhatsAppLoginResult } from "./connection-controller-ja6z4F_k.js";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, success } from "openclaw/plugin-sdk/runtime-env";

package/dist/{login-qr-l4UaR8Dj.js → login-qr-BVRx8j_M.js}

@@ -1,7 +1,7 @@
 import { a as resolveWhatsAppAccount } from "./accounts-BPYgj8Fv.js";
-import { f as readWebAuthExistsForDecision, g as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-GTQvJznL.js";
-import { i as resolveWhatsAppSocketTiming, t as createWaSocket } from "./session-CPsgRMMa.js";
-import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-9TXWZRhx.js";
+import { f as readWebAuthExistsForDecision, g as readWebSelfId, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BrKb0mwT.js";
+import { i as resolveWhatsAppSocketTiming, t as createWaSocket } from "./session-CDgpDc0l.js";
+import { i as closeWaSocket, o as waitForWhatsAppLoginResult, t as WHATSAPP_LOGGED_OUT_QR_MESSAGE } from "./connection-controller-ja6z4F_k.js";
 import { logInfo } from "openclaw/plugin-sdk/logging-core";
 import { danger, defaultRuntime, info, success } from "openclaw/plugin-sdk/runtime-env";
 import { renderQrPngDataUrl } from "openclaw/plugin-sdk/media-runtime";

package/dist/login-qr-runtime.js

@@ -1,7 +1,7 @@
 //#region extensions/whatsapp/login-qr-runtime.ts
 let loginQrModulePromise = null;
 function loadLoginQrModule() {
-	loginQrModulePromise ??= import("./login-qr-l4UaR8Dj.js");
+	loginQrModulePromise ??= import("./login-qr-BVRx8j_M.js");
 	return loginQrModulePromise;
 }
 async function startWebLoginWithQr(...args) {