@openclaw/whatsapp 2026.7.2-beta.7 → 2026.8.1-beta.3

package/dist/{auth-store-DcEpIOmE.js → auth-store-CtpBqH5S.js}

@@ -1,13 +1,14 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as readWebCredsJsonRawSync, c as statWebCredsFileSync, i as readWebCredsJsonRaw, o as resolveWebCredsBackupPath, r as hasWebCredsSync, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { n as resolveUserPath } from "./text-runtime-CaKLhowd.js";
-import { c as resolveComparableIdentity } from "./identity-CPrT5aEU.js";
+import { a as readWebCredsJsonRaw, c as resolveWebCredsPath, i as isWhatsAppBaileysAuthFileName, l as statWebCredsFileSync, o as readWebCredsJsonRawSync, r as hasWebCredsSync, s as resolveWebCredsBackupPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-W6B3EMZ8.js";
+import { r as jidToE164 } from "./targets-runtime-TMk0lGuy.js";
+import { n as resolveUserPath, t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
 import path from "node:path";
 import { resolveOAuthDir as resolveOAuthDir$1 } from "openclaw/plugin-sdk/state-paths";
 import { replaceFileAtomic } from "openclaw/plugin-sdk/security-runtime";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { defaultRuntime, getChildLogger, info, success } from "openclaw/plugin-sdk/runtime-env";
 import fs from "node:fs/promises";
+import { isPathStrictlyInside } from "openclaw/plugin-sdk/file-access-runtime";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/routing";
 import { enqueueKeyedTask } from "openclaw/plugin-sdk/keyed-async-queue";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -68,6 +69,79 @@ async function waitForCredsSaveQueueWithTimeout(authDir, timeoutMs = CREDS_SAVE_
 	});
 }
 //#endregion
+//#region extensions/whatsapp/src/identity.ts
+const WHATSAPP_LID_RE = /@(lid|hosted\.lid)$/i;
+function normalizeDeviceScopedJid(jid) {
+	return jid ? jid.replace(/:\d+/, "") : null;
+}
+function isLidJid(jid) {
+	return Boolean(jid && WHATSAPP_LID_RE.test(jid));
+}
+function resolveComparableIdentity(identity, authDir) {
+	const rawJid = normalizeDeviceScopedJid(identity?.jid);
+	const lid = normalizeDeviceScopedJid(identity?.lid) ?? (isLidJid(rawJid) ? rawJid : null);
+	const jid = rawJid && !isLidJid(rawJid) ? rawJid : null;
+	const e164 = identity?.e164 != null ? normalizeE164(identity.e164) : (jid ? jidToE164(jid, authDir ? { authDir } : void 0) : null) ?? (lid ? jidToE164(lid, authDir ? { authDir } : void 0) : null);
+	return {
+		...identity,
+		jid,
+		lid,
+		e164
+	};
+}
+function getComparableIdentityValues(identity) {
+	const resolved = resolveComparableIdentity(identity);
+	return [
+		resolved.e164,
+		resolved.jid,
+		resolved.lid
+	].filter((value) => Boolean(value));
+}
+function identitiesOverlap(left, right) {
+	const leftValues = new Set(getComparableIdentityValues(left));
+	if (leftValues.size === 0) return false;
+	return getComparableIdentityValues(right).some((value) => leftValues.has(value));
+}
+function getSenderIdentity(msg, authDir) {
+	return resolveComparableIdentity(msg.platform.sender ?? {
+		jid: msg.platform.senderJid ?? null,
+		e164: msg.platform.senderE164 ?? null,
+		name: msg.platform.senderName ?? null
+	}, authDir);
+}
+function getSelfIdentity(msg, authDir) {
+	return resolveComparableIdentity(msg.platform.self ?? {
+		jid: msg.platform.selfJid ?? null,
+		lid: msg.platform.selfLid ?? null,
+		e164: msg.platform.selfE164 ?? null
+	}, authDir);
+}
+function getReplyContext(msg, authDir) {
+	if (msg.quote?.context) return {
+		...msg.quote.context,
+		sender: resolveComparableIdentity(msg.quote.context.sender, authDir)
+	};
+	if (!msg.quote?.body) return null;
+	return {
+		id: msg.quote.id,
+		body: msg.quote.body,
+		sender: resolveComparableIdentity({
+			jid: msg.quote.sender?.jid ?? null,
+			e164: msg.quote.sender?.e164 ?? null,
+			label: msg.quote.sender?.displayName ?? null
+		}, authDir)
+	};
+}
+function getMentionJids(msg) {
+	return msg.group?.mentions?.jids ?? [];
+}
+function getMentionIdentities(msg, authDir) {
+	return getMentionJids(msg).map((jid) => resolveComparableIdentity({ jid }, authDir));
+}
+function getPrimaryIdentityId(identity) {
+	return identity?.e164 || identity?.jid?.trim() || identity?.lid || null;
+}
+//#endregion
 //#region extensions/whatsapp/src/auth-store.ts
 var auth_store_exports = /* @__PURE__ */ __exportAll({
 	WA_WEB_AUTH_DIR: () => WA_WEB_AUTH_DIR,
@@ -235,16 +309,10 @@ async function readWebAuthSnapshotBestEffort(authDir = resolveDefaultWebAuthDir(
 		selfId: snapshot.selfId
 	};
 }
-function isBaileysAuthFileName(name) {
-	if (name === "oauth.json") return false;
-	if (name === "creds.json" || name === "creds.json.bak") return true;
-	if (!name.endsWith(".json")) return false;
-	return /^(app-state-sync|session|sender-key|pre-key)-/.test(name);
-}
 async function clearBaileysAuthFiles(authDir, beforeCredentialPersistence) {
 	const rootStats = await fs.lstat(authDir).catch(() => null);
 	if (!rootStats?.isDirectory() || rootStats.isSymbolicLink()) return;
-	const credentialFiles = (await fs.readdir(authDir, { withFileTypes: true })).filter((entry) => entry.isFile() && isBaileysAuthFileName(entry.name));
+	const credentialFiles = (await fs.readdir(authDir, { withFileTypes: true })).filter((entry) => entry.isFile() && isWhatsAppBaileysAuthFileName(entry.name));
 	if (credentialFiles.length === 0) return;
 	await beforeCredentialPersistence?.();
 	await Promise.all(credentialFiles.map(async (entry) => {
@@ -257,7 +325,7 @@ async function shouldClearOnLogout(authDir, isLegacyAuthDir) {
 		if (!stats.isDirectory() || stats.isSymbolicLink()) return false;
 		if (isLegacyAuthDir) return (await fs.readdir(authDir, { withFileTypes: true })).some((entry) => {
 			if (!entry.isFile()) return false;
-			return isBaileysAuthFileName(entry.name);
+			return isWhatsAppBaileysAuthFileName(entry.name);
 		});
 		if ((await fs.lstat(resolveWebCredsPath(authDir)).catch(() => null))?.isFile()) return true;
 		return (await fs.lstat(resolveWebCredsBackupPath(authDir)).catch(() => null))?.isFile() === true;
@@ -266,10 +334,6 @@ async function shouldClearOnLogout(authDir, isLegacyAuthDir) {
 		return (typeof codeValue === "string" ? codeValue : "") !== "ENOENT";
 	}
 }
-function isPathInsideDirectory(baseDir, targetPath) {
-	const relativePath = path.relative(baseDir, targetPath);
-	return relativePath !== "" && !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
-}
 async function pathHasSymlinkComponent(baseDir, targetPath) {
 	const relativePath = path.relative(baseDir, targetPath);
 	let currentPath = baseDir;
@@ -290,10 +354,10 @@ async function isLegacyWebAuthDir(authDir) {
 async function classifyWebAuthDirOwnership(authDir) {
 	const whatsappAuthBase = path.resolve(resolveOAuthDir$1(), "whatsapp");
 	const resolvedAuthDir = path.resolve(authDir);
-	if (!isPathInsideDirectory(whatsappAuthBase, resolvedAuthDir)) return { kind: "external" };
+	if (!isPathStrictlyInside(whatsappAuthBase, resolvedAuthDir)) return { kind: "external" };
 	const [baseRealPath, authDirRealPath] = await Promise.all([fs.realpath(whatsappAuthBase).catch(() => null), fs.realpath(resolvedAuthDir).catch(() => null)]);
 	if (!baseRealPath || !authDirRealPath) return { kind: "unsafe-owned" };
-	if (!isPathInsideDirectory(baseRealPath, authDirRealPath)) return { kind: "unsafe-owned" };
+	if (!isPathStrictlyInside(baseRealPath, authDirRealPath)) return { kind: "unsafe-owned" };
 	if (await pathHasSymlinkComponent(whatsappAuthBase, resolvedAuthDir)) return { kind: "unsafe-owned" };
 	return {
 		kind: "owned",
@@ -397,4 +461,4 @@ async function pickWebChannel(pref, authDir = resolveDefaultWebAuthDir()) {
 	return choice;
 }
 //#endregion
-export { waitForCredsSaveQueue as C, writeWebCredsRawAtomically as E, enqueueCredsSave as S, writeCredsJsonAtomically as T, readWebSelfIdentity as _, formatWhatsAppWebAuthStatusState as a, restoreCredsFromBackupIfNeeded as b, logoutWeb as c, readWebAuthExistsBestEffort as d, readWebAuthExistsForDecision as f, readWebSelfId as g, readWebAuthState as h, auth_store_exports as i, pickWebChannel as l, readWebAuthSnapshotBestEffort as m, WHATSAPP_AUTH_UNSTABLE_CODE as n, getWebAuthAgeMs as o, readWebAuthSnapshot as p, WhatsAppAuthUnstableError as r, logWebSelfId as s, WA_WEB_AUTH_DIR as t, readCredsJsonRaw as u, readWebSelfIdentityForDecision as v, waitForCredsSaveQueueWithTimeout as w, webAuthExists as x, resolveDefaultWebAuthDir as y };
+export { enqueueCredsSave as A, getMentionIdentities as C, getSenderIdentity as D, getSelfIdentity as E, waitForCredsSaveQueueWithTimeout as M, writeCredsJsonAtomically as N, identitiesOverlap as O, writeWebCredsRawAtomically as P, getComparableIdentityValues as S, getReplyContext as T, readWebSelfIdentity as _, formatWhatsAppWebAuthStatusState as a, restoreCredsFromBackupIfNeeded as b, logoutWeb as c, readWebAuthExistsBestEffort as d, readWebAuthExistsForDecision as f, readWebSelfId as g, readWebAuthState as h, auth_store_exports as i, waitForCredsSaveQueue as j, resolveComparableIdentity as k, pickWebChannel as l, readWebAuthSnapshotBestEffort as m, WHATSAPP_AUTH_UNSTABLE_CODE as n, getWebAuthAgeMs as o, readWebAuthSnapshot as p, WhatsAppAuthUnstableError as r, logWebSelfId as s, WA_WEB_AUTH_DIR as t, readCredsJsonRaw as u, readWebSelfIdentityForDecision as v, getPrimaryIdentityId as w, webAuthExists as x, resolveDefaultWebAuthDir as y };

package/dist/call-tool-api.js

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
+import { a as resolveWhatsAppAccount } from "./accounts-BX2fZUyR.js";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
 import { s as resolveJidToE164 } from "./targets-runtime-TMk0lGuy.js";
 import { createActionGate, stringEnum } from "openclaw/plugin-sdk/channel-actions";

package/dist/{channel-Dg62olhy.js → channel-DRMYRfZ8.js}

@@ -1,22 +1,21 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
+import { a as resolveWhatsAppAccount } from "./accounts-BX2fZUyR.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, n as isWhatsAppNewsletterJid, o as normalizeWhatsAppAllowFromEntry, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-CugRyONv.js";
 import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-1GqbT1uX.js";
-import { a as normalizeWhatsAppOutboundPayload, i as sendTypingWhatsApp, n as sendPollWhatsApp, o as normalizeWhatsAppPayloadText, s as normalizeWhatsAppPayloadTextPreservingIndentation, t as sendMessageWhatsApp, u as resolveWhatsAppReactionLevel } from "./send-D37ddk22.js";
+import { c as normalizeWhatsAppPayloadTextPreservingIndentation, i as sendTypingWhatsApp, n as sendPollWhatsApp, o as normalizeWhatsAppOutboundPayload, s as normalizeWhatsAppPayloadText, t as sendMessageWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-CwvTU4RI.js";
 import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import "./normalize-C7Hkc_vE.js";
 import { c as toWhatsappJid } from "./targets-runtime-TMk0lGuy.js";
 import "./text-runtime-CaKLhowd.js";
-import { t as createWhatsAppLoginTool } from "./agent-tools-login-DE9MU98T.js";
-import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth, s as lookupInboundMessageMetaForTarget, t as resolveWhatsAppGroupSessionKey } from "./group-session-key-DVMZlO3x.js";
-import { a as resolveWhatsAppGroupRequireMention, c as loadWhatsAppChannelRuntime, i as whatsappSetupContract, l as readWhatsAppAccountLinkState, n as whatsappSetupWizardProxy, o as resolveWhatsAppGroupToolPolicy, r as whatsappSetupAdapter, s as formatWhatsAppConfigAllowFromEntries, t as createWhatsAppPluginBase } from "./shared-CAxd15bp.js";
+import { t as createWhatsAppLoginTool } from "./agent-tools-login-BjRpD-JQ.js";
+import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth, s as lookupInboundMessageMetaForTarget, t as resolveWhatsAppGroupSessionKey } from "./group-session-key-DmFc_Cqi.js";
+import { a as resolveWhatsAppGroupRequireMention, c as loadWhatsAppChannelRuntime, i as whatsappSetupContract, l as readWhatsAppAccountLinkState, n as whatsappSetupWizardProxy, o as resolveWhatsAppGroupToolPolicy, s as formatWhatsAppConfigAllowFromEntries, t as createWhatsAppPluginBase } from "./shared-wg42NKFB.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import { f as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-DcEpIOmE.js";
-import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-CAMTrs2U.js";
+import { f as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-CtpBqH5S.js";
 import { createActionGate as createActionGate$1 } from "openclaw/plugin-sdk/channel-actions";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-core";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { asString, collectIssuesForEnabledAccounts, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, isRecord as isRecord$1, readAccountStatusSnapshot } from "openclaw/plugin-sdk/status-helpers";
+import { collectIssuesForEnabledAccounts, createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, isRecord as isRecord$1, readAccountStatusSnapshot } from "openclaw/plugin-sdk/status-helpers";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { buildChannelOutboundSessionRoute } from "openclaw/plugin-sdk/core";
 import { chunkText } from "openclaw/plugin-sdk/reply-chunking";
@@ -26,180 +25,76 @@ import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "openclaw/plugin-sdk/
 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 { createChannelApprovalCapability } from "openclaw/plugin-sdk/approval-delivery-runtime";
+import { createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes } from "openclaw/plugin-sdk/approval-delivery-runtime";
 import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
-import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor, createNativeApprovalMessagingTargetResolvers } from "openclaw/plugin-sdk/approval-native-runtime";
 import { buildApprovalReactionPromptPayloadForRequest } from "openclaw/plugin-sdk/approval-reaction-runtime";
 import { buildTypedApprovalPresentation } from "openclaw/plugin-sdk/approval-reply-runtime";
 import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
 //#region extensions/whatsapp/src/approval-native.ts
-const DEFAULT_APPROVAL_FORWARDING_MODE = "session";
-const { normalizeForwardTarget: normalizeWhatsAppForwardTarget, normalizeTarget: normalizeWhatsAppApprovalTarget, resolveSessionTarget: resolveSessionWhatsAppOriginTarget, resolveTurnSourceTarget: resolveTurnSourceWhatsAppOriginTarget } = createNativeApprovalMessagingTargetResolvers({
-	channel: "whatsapp",
-	normalizeTo: normalizeWhatsAppMessagingTarget
-});
 function isWhatsAppApprovalTransportEnabled(params) {
 	return resolveWhatsAppAccount({
 		cfg: params.cfg,
 		accountId: params.accountId
 	}).enabled;
 }
-const { canApprovalPotentiallyRouteToChannel: canApprovalPotentiallyRouteToWhatsApp, canAnyApprovalPotentiallyRouteToChannel: canAnyApprovalPotentiallyRouteToWhatsApp, isSessionApprovalEligible: isWhatsAppSessionApprovalEligible, isExplicitTargetEligible: isWhatsAppExplicitTargetEligible, shouldHandleApprovalRequest: shouldHandleWhatsAppApprovalRequest } = createNativeApprovalChannelRouteGates({
-	channel: "whatsapp",
-	defaultForwardingMode: DEFAULT_APPROVAL_FORWARDING_MODE,
-	isTransportEnabled: isWhatsAppApprovalTransportEnabled,
-	listAccountIds,
-	resolveDefaultAccountId: resolveDefaultWhatsAppAccountId,
-	normalizeForwardTarget: normalizeWhatsAppForwardTarget,
-	resolveTurnSourceTarget: resolveTurnSourceWhatsAppOriginTarget
-});
-const resolveWhatsAppOriginTargetBase = createChannelNativeOriginTargetResolver({
-	channel: "whatsapp",
-	shouldHandleRequest: shouldHandleWhatsAppApprovalRequest,
-	resolveTurnSourceTarget: resolveTurnSourceWhatsAppOriginTarget,
-	resolveSessionTarget: resolveSessionWhatsAppOriginTarget,
-	normalizeTarget: normalizeWhatsAppApprovalTarget
-});
-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)
-		};
-	}
-});
-const shouldSuppressWhatsAppForwardingFallback = createNativeApprovalForwardingFallbackSuppressor({
+const whatsappApproval = createApproverRestrictedNativeApprovalCapabilityFromForwardingRoutes({
 	channel: "whatsapp",
-	normalizeForwardTarget: normalizeWhatsAppForwardTarget,
-	resolveAccountId: ({ forwardingTarget, request }) => forwardingTarget.accountId ?? normalizeOptionalString(request.request.turnSourceAccountId),
-	resolveForwardingTargetForMatch: ({ forwardingTarget, accountId }) => ({
-		...forwardingTarget,
-		accountId
-	}),
-	isSessionRouteEligible: isWhatsAppSessionApprovalEligible,
-	isExplicitTargetEligible: isWhatsAppExplicitTargetEligible,
-	resolveOriginTarget: resolveWhatsAppOriginTarget,
-	resolveApproverDmTargets: resolveWhatsAppApproverDmTargets
-});
-function buildWhatsAppExecPendingPayload(params) {
-	const payload = buildApprovalReactionPromptPayloadForRequest(params);
-	return {
-		...payload,
-		presentation: buildTypedApprovalPresentation({
-			approvalId: params.request.id,
-			approvalKind: "exec",
-			allowedDecisions: payload.allowedDecisions
-		})
-	};
-}
-function buildWhatsAppPluginPendingPayload(params) {
-	const payload = buildApprovalReactionPromptPayloadForRequest(params);
-	return {
-		...payload,
-		presentation: buildTypedApprovalPresentation({
-			approvalId: params.request.id,
-			approvalKind: "plugin",
-			allowedDecisions: payload.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" },
+	channelLabel: "WhatsApp",
+	authorizeActorAction: (params) => whatsappApprovalAuth.authorizeActorAction(params),
+	routing: {
+		defaultForwardingMode: "session",
+		isTransportEnabled: isWhatsAppApprovalTransportEnabled,
+		listAccountIds,
+		resolveDefaultAccountId: resolveDefaultWhatsAppAccountId,
+		normalizeTo: normalizeWhatsAppMessagingTarget,
+		resolveApprovers: getWhatsAppApprovalApprovers,
+		isOriginTargetAllowed: ({ cfg, accountId, target }) => !isWhatsAppGroupJid(target.to) || getWhatsAppApprovalApprovers({
+			cfg,
+			accountId
+		}).length > 0
+	},
 	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.`;
 	},
-	delivery: {
-		hasConfiguredDmRoute: ({ cfg }) => listAccountIds(cfg).some((accountId) => {
-			if (!canAnyApprovalPotentiallyRouteToWhatsApp({
-				cfg,
-				accountId,
-				nativeSessionOnly: true
-			})) return false;
-			return getWhatsAppApprovalApprovers({
-				cfg,
-				accountId
-			}).length > 0;
-		}),
-		shouldSuppressForwardingFallback: shouldSuppressWhatsAppForwardingFallback
-	},
 	render: {
-		exec: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppExecPendingPayload({
+		exec: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppPendingPayload({
 			request,
 			nowMs
-		}) },
-		plugin: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppPluginPendingPayload({
+		}, "exec") },
+		plugin: { buildPendingPayload: ({ request, nowMs }) => buildWhatsAppPendingPayload({
 			request,
 			nowMs
-		}) }
+		}, "plugin") }
 	},
-	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({
+	createNativeRuntime: (routing) => createLazyChannelApprovalNativeRuntimeAdapter({
 		eventKinds: ["exec", "plugin"],
-		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && canAnyApprovalPotentiallyRouteToWhatsApp({
+		isConfigured: ({ cfg, accountId, context }) => Boolean(context) && routing.canAnyApprovalPotentiallyRouteToChannel({
 			cfg,
 			accountId,
 			nativeSessionOnly: true
 		}),
-		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && shouldHandleWhatsAppApprovalRequest({
+		shouldHandle: ({ cfg, accountId, context, approvalKind, request }) => Boolean(context) && routing.shouldHandleApprovalRequest({
 			cfg,
 			accountId,
 			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-DrA59QSA.js")).whatsappApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-CkMMvUjk.js")).whatsappApprovalNativeRuntime
 	})
 });
+function buildWhatsAppPendingPayload(params, approvalKind) {
+	const payload = buildApprovalReactionPromptPayloadForRequest(params);
+	return {
+		...payload,
+		presentation: buildTypedApprovalPresentation({
+			approvalId: params.request.id,
+			approvalKind,
+			allowedDecisions: payload.allowedDecisions
+		})
+	};
+}
+const whatsappApprovalCapability = whatsappApproval.capability;
 //#endregion
 //#region extensions/whatsapp/src/channel-actions.ts
 function areWhatsAppAgentReactionsEnabled(params) {
@@ -266,6 +161,7 @@ function createWhatsAppOutboundBase({ chunker, sendMessageWhatsApp, sendPollWhat
 			remoteJid: cachedMeta?.remoteJid ?? targetJid,
 			fromMe: cachedMeta?.fromMe ?? false,
 			participant: cachedMeta?.participant,
+			...cachedMeta && cachedMeta.remoteJid !== targetJid ? { lookupTargetJid: targetJid } : {},
 			messageText: cachedMeta?.body,
 			media: cachedMeta?.media
 		};
@@ -364,8 +260,8 @@ function createWhatsAppOutboundBase({ chunker, sendMessageWhatsApp, sendPollWhat
 }
 //#endregion
 //#region extensions/whatsapp/src/channel-outbound.ts
-const loadWhatsAppApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-Cu66aYdq.js").then((n) => n.t));
-const loadWhatsAppQuestionReactionsModule = createLazyRuntimeModule(() => import("./question-reactions-CRsnyoMK.js").then((n) => n.n));
+const loadWhatsAppApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-Jyr1JaAK.js").then((n) => n.t));
+const loadWhatsAppQuestionReactionsModule = createLazyRuntimeModule(() => import("./question-reactions-D3eAeB0i.js").then((n) => n.n));
 function normalizeWhatsAppChannelPayloadText(text) {
 	return normalizeWhatsAppPayloadTextPreservingIndentation(text);
 }
@@ -525,7 +421,7 @@ const WHATSAPP_ACCOUNT_STATUS_FIELDS = [
 const RECENT_DISCONNECT_WARNING_WINDOW_MS = 900 * 1e3;
 function readLastDisconnect(value) {
 	if (typeof value === "string") {
-		const error = asString(value);
+		const error = normalizeOptionalString(value);
 		return error ? {
 			at: null,
 			error
@@ -534,7 +430,7 @@ function readLastDisconnect(value) {
 	if (!isRecord$1(value)) return null;
 	return {
 		at: typeof value.at === "number" ? value.at : null,
-		error: asString(value.error)
+		error: normalizeOptionalString(value.error)
 	};
 }
 function isRecentDisconnect(disconnect, now = Date.now()) {
@@ -547,14 +443,14 @@ function collectWhatsAppStatusIssues(accounts) {
 		readAccount: (value) => readAccountStatusSnapshot(value, WHATSAPP_ACCOUNT_STATUS_FIELDS),
 		collectIssues: ({ account, accountId, issues }) => {
 			const linked = account.linked === true;
-			const statusState = asString(account.statusState);
+			const statusState = normalizeOptionalString(account.statusState);
 			const running = account.running === true;
 			const connected = account.connected === true;
 			const reconnectAttempts = typeof account.reconnectAttempts === "number" ? account.reconnectAttempts : null;
 			const lastInboundAt = typeof account.lastInboundAt === "number" ? account.lastInboundAt : null;
 			const lastDisconnect = readLastDisconnect(account.lastDisconnect);
-			const lastError = asString(account.lastError) ?? lastDisconnect?.error;
-			const healthState = asString(account.healthState);
+			const lastError = normalizeOptionalString(account.lastError) ?? lastDisconnect?.error;
+			const healthState = normalizeOptionalString(account.healthState);
 			if (statusState === "unstable") {
 				issues.push({
 					channel: "whatsapp",
@@ -629,8 +525,8 @@ function collectWhatsAppStatusIssues(accounts) {
 }
 //#endregion
 //#region extensions/whatsapp/src/channel.ts
-const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-DalGrfGN.js").then((n) => n.t));
-const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-J_YtyMGX.js"));
+const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-P7_3U73Z.js").then((n) => n.t));
+const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-CstrR0CT.js"));
 function resolveWhatsAppTargetInfo(raw) {
 	const normalized = normalizeWhatsAppTarget(raw);
 	if (!normalized) return null;
@@ -663,7 +559,6 @@ const whatsappPlugin = createChatChannelPlugin({
 				resolveToolPolicy: resolveWhatsAppGroupToolPolicy
 			},
 			setupWizard: whatsappSetupWizardProxy,
-			setup: whatsappSetupAdapter,
 			setupContract: whatsappSetupContract,
 			isConfigured: (account) => Boolean(account.authDir),
 			isLinked: async (account) => await readWhatsAppAccountLinkState(account.authDir)
@@ -766,7 +661,6 @@ const whatsappPlugin = createChatChannelPlugin({
 			const resolvedAccountId = accountId?.trim() || whatsappPlugin.config.defaultAccountId?.(cfg) || DEFAULT_ACCOUNT_ID$1;
 			await (await loadWhatsAppChannelRuntime()).loginWeb(Boolean(verbose), void 0, runtime, resolvedAccountId);
 		} },
-		lifecycle: { detectLegacyStateMigrations: ({ oauthDir }) => detectWhatsAppLegacyStateMigrations({ oauthDir }) },
 		heartbeat: {
 			checkReady: async ({ cfg, accountId, deps }) => await checkWhatsAppHeartbeatReady({
 				cfg,
@@ -791,7 +685,8 @@ const whatsappPlugin = createChatChannelPlugin({
 				lastEventAt: null,
 				busy: false,
 				lastRunActivityAt: null,
-				healthState: "stopped"
+				healthState: "stopped",
+				lifecycle: "stopped"
 			}),
 			collectStatusIssues: collectWhatsAppStatusIssues,
 			buildChannelSummary: async ({ account, snapshot }) => {
@@ -833,6 +728,7 @@ const whatsappPlugin = createChatChannelPlugin({
 					lastRunActivityAt: snapshot.lastRunActivityAt ?? null,
 					lastError: snapshot.lastError ?? null,
 					healthState: snapshot.healthState ?? void 0,
+					lifecycle: snapshot.lifecycle ?? void 0,
 					...snapshot.terminalDisconnect ? { terminalDisconnect: snapshot.terminalDisconnect } : {}
 				};
 			},

package/dist/channel-plugin-api.js

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

package/dist/{channel-react-action-J_YtyMGX.js → channel-react-action-CstrR0CT.js}

@@ -1,7 +1,7 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CSqLvCY5.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BX2fZUyR.js";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-CugRyONv.js";
-import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-BzfDFPbH.js";
-import { t as sendMessageWhatsApp } from "./send-D37ddk22.js";
+import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-pM-ExU0l.js";
+import { a as sendWhatsAppUploadFile } from "./send-CwvTU4RI.js";
 import "./normalize-C7Hkc_vE.js";
 import { jsonResult, readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { canonicalizeBase64, estimateBase64DecodedBytes } from "openclaw/plugin-sdk/media-runtime";
@@ -23,17 +23,14 @@ function readWhatsAppActionChatJid(params) {
 	if (params.toolContext?.currentChannelProvider !== WHATSAPP_CHANNEL || !params.toolContext.currentChannelId) return;
 	return normalizeWhatsAppTarget(params.toolContext.currentChannelId) ?? void 0;
 }
-function extractBase64Payload(encoded) {
-	return /^data:[^;]+;base64,(.*)$/is.exec(encoded.trim())?.[1] ?? encoded;
-}
 function decodeUploadFileMediaPayload(params) {
-	const payload = extractBase64Payload(params.encoded);
+	const dataUrl = /^data:([^;]+);base64,(.*)$/is.exec(params.encoded.trim());
+	const payload = dataUrl?.[2] ?? params.encoded;
 	if (params.maxBytes !== void 0) {
 		const estimatedBytes = estimateBase64DecodedBytes(payload);
 		if (estimatedBytes > params.maxBytes) throw new Error(`WhatsApp upload-file buffer exceeds configured media limit (${estimatedBytes} bytes > ${params.maxBytes} bytes).`);
 	}
-	const contentType = readStringParam$1(params.args, "contentType") ?? readStringParam$1(params.args, "mimeType");
-	const fileName = readStringParam$1(params.args, "filename") ?? readStringParam$1(params.args, "fileName");
+	const contentType = params.contentType ?? dataUrl?.[1];
 	const canonicalPayload = canonicalizeBase64(payload);
 	if (!canonicalPayload) throw new Error("WhatsApp upload-file buffer must be valid base64 or a base64 data URL.");
 	const buffer = Buffer.from(canonicalPayload, "base64");
@@ -41,12 +38,14 @@ function decodeUploadFileMediaPayload(params) {
 	return {
 		buffer,
 		...contentType ? { contentType } : {},
-		...fileName ? { fileName } : {}
+		...params.fileName ? { fileName: params.fileName } : {}
 	};
 }
 async function handleWhatsAppUploadFileAction(params) {
 	const mediaUrl = readUploadFileMediaSource(params.params);
 	const encodedPayload = readStringParam$1(params.params, "buffer", { trim: false });
+	const contentType = readStringParam$1(params.params, "contentType") ?? readStringParam$1(params.params, "mimeType");
+	const fileName = readStringParam$1(params.params, "filename") ?? readStringParam$1(params.params, "fileName");
 	if (!mediaUrl && !hasUploadFileBufferPayload(params.params)) throw new Error("WhatsApp upload-file requires media, mediaUrl, filePath, path, fileUrl, or buffer.");
 	const to = readWhatsAppActionChatJid(params) ?? readStringParam$1(params.params, "to", { required: true });
 	const resolved = resolveAuthorizedWhatsAppOutboundTarget({
@@ -60,15 +59,18 @@ async function handleWhatsAppUploadFileAction(params) {
 		accountId: resolved.accountId
 	});
 	const mediaPayload = encodedPayload ? decodeUploadFileMediaPayload({
-		args: params.params,
 		encoded: encodedPayload,
+		contentType,
+		fileName,
 		maxBytes: resolveWhatsAppMediaMaxBytes(account)
 	}) : void 0;
-	const result = await sendMessageWhatsApp(resolved.to, readUploadFileCaptionText(params.params), {
+	const result = await sendWhatsAppUploadFile(resolved.to, readUploadFileCaptionText(params.params), {
 		verbose: false,
 		cfg: params.cfg,
 		...mediaUrl && !mediaPayload ? { mediaUrl } : {},
 		...mediaPayload ? { mediaPayload } : {},
+		...mediaUrl && !mediaPayload && fileName ? { fileName } : {},
+		...mediaUrl && !mediaPayload && contentType ? { contentType } : {},
 		mediaAccess: params.mediaAccess,
 		mediaLocalRoots: params.mediaLocalRoots,
 		mediaReadFile: params.mediaReadFile,

package/dist/{channel.runtime-BP0xNmLi.js → channel.runtime-X3JC2gaq.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-DcEpIOmE.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-CtpBqH5S.js";
 import { t as getActiveWebListener$1 } from "./active-listener-BEjWsCNM.js";
-import { t as monitorWebChannel$1 } from "./monitor-CfkaUSL2.js";
-import { t as loginWeb$1 } from "./login-CvY2Dhch.js";
-import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-BkVcd769.js";
+import { t as monitorWebChannel$1 } from "./monitor-IzwQKizW.js";
+import { t as loginWeb$1 } from "./login-BkpKpndm.js";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-Cwn3zyxK.js";
 //#region extensions/whatsapp/src/channel.runtime.ts
 function getActiveWebListener(...args) {
 	return getActiveWebListener$1(...args);

package/dist/channel.setup-DhBBhbQv.js

@@ -0,0 +1,14 @@
+import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupContract, l as readWhatsAppAccountLinkState, n as whatsappSetupWizardProxy, o as resolveWhatsAppGroupToolPolicy, t as createWhatsAppPluginBase } from "./shared-wg42NKFB.js";
+//#region extensions/whatsapp/src/channel.setup.ts
+const whatsappSetupPlugin = { ...createWhatsAppPluginBase({
+	groups: {
+		resolveRequireMention: resolveWhatsAppGroupRequireMention,
+		resolveToolPolicy: resolveWhatsAppGroupToolPolicy
+	},
+	setupWizard: whatsappSetupWizardProxy,
+	setupContract: whatsappSetupContract,
+	isConfigured: (account) => Boolean(account.authDir),
+	isLinked: async (account) => await readWhatsAppAccountLinkState(account.authDir)
+}) };
+//#endregion
+export { whatsappSetupPlugin as t };

package/dist/{connection-controller-BOB2MVKY.js → connection-controller-CIYuBJrs.js}

@@ -1,8 +1,7 @@
 import { r as getWhatsAppChannelRuntime } from "./runtime-BLlToOi6.js";
 import { n as WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY, t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-DG0tuYuw.js";
-import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError, w as waitForCredsSaveQueueWithTimeout } from "./auth-store-DcEpIOmE.js";
-import { c as resolveComparableIdentity } from "./identity-CPrT5aEU.js";
-import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-DridEuzz.js";
+import { M as waitForCredsSaveQueueWithTimeout, c as logoutWeb, f as readWebAuthExistsForDecision, k as resolveComparableIdentity, r as WhatsAppAuthUnstableError } from "./auth-store-CtpBqH5S.js";
+import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-2T0_jZTN.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import { computeBackoff, info, sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";

package/dist/contract-api.js

@@ -2,7 +2,7 @@ import { c as normalizeWhatsAppTarget$1, t as isWhatsAppGroupJid$1 } from "./nor
 import { t as whatsappCommandPolicy$1 } from "./command-policy-BIOSHySD.js";
 import { t as resolveLegacyGroupSessionKey$1 } from "./group-session-contract-DDnZSsJ1.js";
 import { r as isLegacyGroupSessionKey$1, t as canonicalizeLegacySessionKey$1 } from "./session-contract-DMTm6Q_L.js";
-import { a as resolveWhatsAppRuntimeGroupPolicy$1, n as testing } from "./access-control-pZcxTmd5.js";
+import { t as resolveWhatsAppRuntimeGroupPolicy$1 } from "./runtime-group-policy-DeSRFXEV.js";
 //#region extensions/whatsapp/contract-api.ts
 const canonicalizeLegacySessionKey = canonicalizeLegacySessionKey$1;
 const isLegacyGroupSessionKey = isLegacyGroupSessionKey$1;
@@ -10,7 +10,6 @@ const isWhatsAppGroupJid = isWhatsAppGroupJid$1;
 const normalizeWhatsAppTarget = normalizeWhatsAppTarget$1;
 const resolveLegacyGroupSessionKey = resolveLegacyGroupSessionKey$1;
 const resolveWhatsAppRuntimeGroupPolicy = resolveWhatsAppRuntimeGroupPolicy$1;
-const whatsappAccessControlTesting = testing;
 const whatsappCommandPolicy = whatsappCommandPolicy$1;
 //#endregion
-export { canonicalizeLegacySessionKey, isLegacyGroupSessionKey, isWhatsAppGroupJid, normalizeWhatsAppTarget, resolveLegacyGroupSessionKey, resolveWhatsAppRuntimeGroupPolicy, whatsappAccessControlTesting, whatsappCommandPolicy };
+export { canonicalizeLegacySessionKey, isLegacyGroupSessionKey, isWhatsAppGroupJid, normalizeWhatsAppTarget, resolveLegacyGroupSessionKey, resolveWhatsAppRuntimeGroupPolicy, whatsappCommandPolicy };