@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.33

package/dist/channel-DcWBc3Hb.js

@@ -1,911 +0,0 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.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-BTXJAyK4.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-DfyToBpG.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 isWhatsAppAuthConfigured, i as whatsappSetupContract, l as loadWhatsAppChannelRuntime, n as whatsappSetupWizardProxy, o as resolveWhatsAppGroupToolPolicy, r as whatsappSetupAdapter, s as formatWhatsAppConfigAllowFromEntries, t as createWhatsAppPluginBase } from "./shared-UcAwtJaq.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 { 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, createAsyncComputedAccountStatusAdapter, 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";
-import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
-import { sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } 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 { createChannelApprovalCapability } 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({
-	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" },
-	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({
-			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, approvalKind, request }) => Boolean(context) && shouldHandleWhatsAppApprovalRequest({
-			cfg,
-			accountId,
-			approvalKind,
-			request
-		}),
-		load: async () => (await import("./approval-handler.runtime-CmtqgLSQ.js")).whatsappApprovalNativeRuntime
-	})
-});
-//#endregion
-//#region extensions/whatsapp/src/channel-actions.ts
-function areWhatsAppAgentReactionsEnabled(params) {
-	if (!params.cfg.channels?.whatsapp) return false;
-	if (!createActionGate$1(params.cfg.channels.whatsapp.actions)("reactions")) return false;
-	return resolveWhatsAppReactionLevel({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).agentReactionsEnabled;
-}
-function hasAnyWhatsAppAccountWithAgentReactionsEnabled(cfg) {
-	if (!cfg.channels?.whatsapp) return false;
-	return listAccountIds(cfg).some((accountId) => {
-		if (!resolveWhatsAppAccount({
-			cfg,
-			accountId
-		}).enabled) return false;
-		return areWhatsAppAgentReactionsEnabled({
-			cfg,
-			accountId
-		});
-	});
-}
-function resolveWhatsAppAgentReactionGuidance(params) {
-	if (!params.cfg.channels?.whatsapp) return;
-	if (!createActionGate$1(params.cfg.channels.whatsapp.actions)("reactions")) return;
-	const resolved = resolveWhatsAppReactionLevel({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	if (!resolved.agentReactionsEnabled) return;
-	return resolved.agentReactionGuidance;
-}
-function describeWhatsAppMessageActions(params) {
-	if (!params.cfg.channels?.whatsapp) return null;
-	const gate = createActionGate$1(params.cfg.channels.whatsapp.actions);
-	const actions = /* @__PURE__ */ new Set();
-	if (params.accountId != null ? areWhatsAppAgentReactionsEnabled({
-		cfg: params.cfg,
-		accountId: params.accountId ?? void 0
-	}) : hasAnyWhatsAppAccountWithAgentReactionsEnabled(params.cfg)) actions.add("react");
-	if (gate("polls")) actions.add("poll");
-	actions.add("upload-file");
-	return { actions: Array.from(actions) };
-}
-//#endregion
-//#region extensions/whatsapp/src/outbound-send-deps.ts
-const WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS = ["sendWhatsApp"];
-//#endregion
-//#region extensions/whatsapp/src/outbound-base.ts
-function resolveQuoteLookupAccountId(cfg, accountId) {
-	const explicitAccountId = normalizeOptionalAccountId(accountId);
-	if (explicitAccountId) return explicitAccountId;
-	return resolveDefaultWhatsAppAccountId(cfg ?? {});
-}
-function createWhatsAppOutboundBase({ chunker, sendMessageWhatsApp, sendPollWhatsApp, shouldLogVerbose, resolveTarget, normalizeText = normalizeWhatsAppPayloadText, skipEmptyText = true }) {
-	const resolveQuotedMessageKey = (params) => {
-		const replyToId = params.replyToId?.trim();
-		if (!replyToId) return;
-		const targetJid = toWhatsappJid(params.to);
-		const cachedMeta = lookupInboundMessageMetaForTarget(params.accountId, targetJid, replyToId);
-		return {
-			id: replyToId,
-			remoteJid: cachedMeta?.remoteJid ?? targetJid,
-			fromMe: cachedMeta?.fromMe ?? false,
-			participant: cachedMeta?.participant,
-			messageText: cachedMeta?.body,
-			media: cachedMeta?.media
-		};
-	};
-	const outbound = {
-		deliveryMode: "gateway",
-		chunker,
-		chunkerMode: "text",
-		textChunkLimit: 4e3,
-		sanitizeText: ({ text }) => normalizeText(text),
-		deliveryCapabilities: { durableFinal: {
-			text: true,
-			replyTo: true,
-			messageSendingHooks: true
-		} },
-		pollMaxOptions: 12,
-		resolveTarget,
-		...createAttachedChannelResultAdapter({
-			channel: "whatsapp",
-			sendText: async ({ cfg, to, text, accountId, deps, gifPlayback, replyToId, onDeliveryResult }) => {
-				const normalizedText = normalizeText(text);
-				if (skipEmptyText && !normalizedText) return { messageId: "" };
-				const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
-				const quotedMessageKey = resolveQuotedMessageKey({
-					accountId: lookupAccountId,
-					to,
-					replyToId
-				});
-				return await (quotedMessageKey ? sendMessageWhatsApp : resolveOutboundSendDep(deps, "whatsapp", { legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageWhatsApp)(to, normalizedText, {
-					verbose: false,
-					cfg,
-					accountId: accountId ?? void 0,
-					gifPlayback,
-					...quotedMessageKey ? { quotedMessageKey } : {},
-					...onDeliveryResult ? { onDeliveryResult: async (result) => {
-						await onDeliveryResult(attachChannelToResult("whatsapp", result));
-					} } : {}
-				});
-			},
-			sendMedia: async ({ cfg, to, text, mediaUrl, mediaAccess, mediaLocalRoots, mediaReadFile, audioAsVoice, accountId, deps, gifPlayback, forceDocument, replyToId, onDeliveryResult }) => {
-				const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
-				const quotedMessageKey = resolveQuotedMessageKey({
-					accountId: lookupAccountId,
-					to,
-					replyToId
-				});
-				return await (quotedMessageKey ? sendMessageWhatsApp : resolveOutboundSendDep(deps, "whatsapp", { legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS }) ?? sendMessageWhatsApp)(to, normalizeText(text), {
-					verbose: false,
-					cfg,
-					mediaUrl,
-					mediaAccess,
-					mediaLocalRoots,
-					mediaReadFile,
-					...audioAsVoice === void 0 ? {} : { audioAsVoice },
-					accountId: accountId ?? void 0,
-					gifPlayback,
-					forceDocument,
-					...quotedMessageKey ? { quotedMessageKey } : {},
-					...onDeliveryResult ? { onDeliveryResult: async (result) => {
-						await onDeliveryResult(attachChannelToResult("whatsapp", result));
-					} } : {}
-				});
-			},
-			sendPoll: async ({ cfg, to, poll, accountId }) => await sendPollWhatsApp(to, poll, {
-				verbose: shouldLogVerbose(),
-				accountId: accountId ?? void 0,
-				cfg
-			})
-		})
-	};
-	return {
-		...outbound,
-		sendPayload: async (ctx) => {
-			if (ctx.payload.isError === true) return {
-				channel: "whatsapp",
-				messageId: ""
-			};
-			const payload = normalizeWhatsAppOutboundPayload(ctx.payload, { normalizeText });
-			if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
-				if (ctx.payload.interactive || ctx.payload.presentation || ctx.payload.channelData) throw new Error("WhatsApp sendPayload does not support structured-only payloads without text or media.");
-				return {
-					channel: "whatsapp",
-					messageId: ""
-				};
-			}
-			return await sendTextMediaPayload({
-				channel: "whatsapp",
-				ctx: {
-					...ctx,
-					payload
-				},
-				adapter: outbound
-			});
-		}
-	};
-}
-//#endregion
-//#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));
-function normalizeWhatsAppChannelPayloadText(text) {
-	return normalizeWhatsAppPayloadTextPreservingIndentation(text);
-}
-function normalizeWhatsAppChannelSendText(text) {
-	const normalized = normalizeWhatsAppChannelPayloadText(text);
-	return normalized.trim() ? normalized : "";
-}
-async function prepareWhatsAppApprovalPayloadForDelivery(params) {
-	const questionPayload = questionGatewayRuntime.prepareReactionPayloadForDelivery({
-		payload: params.payload,
-		presentation: params.presentation
-	});
-	if (questionPayload) return questionPayload;
-	return (await loadWhatsAppApprovalReactionsModule()).prepareWhatsAppApprovalPayloadForDelivery({
-		payload: params.payload,
-		presentation: params.presentation
-	});
-}
-async function registerDeliveredWhatsAppApprovalPayload(params) {
-	(await loadWhatsAppQuestionReactionsModule()).registerWhatsAppQuestionReactionTargetForDeliveredPayload(params);
-	(await loadWhatsAppApprovalReactionsModule()).registerWhatsAppApprovalReactionTargetForDeliveredPayload(params);
-}
-const whatsappChannelOutbound = {
-	...createWhatsAppOutboundBase({
-		chunker: chunkText,
-		sendMessageWhatsApp: async (to, text, options) => await sendMessageWhatsApp(to, text, {
-			...options,
-			preserveLeadingWhitespace: true
-		}),
-		sendPollWhatsApp,
-		shouldLogVerbose: () => getWhatsAppRuntime().logging.shouldLogVerbose(),
-		resolveTarget: ({ to, allowFrom, mode }) => resolveWhatsAppOutboundTarget({
-			to,
-			allowFrom,
-			mode
-		}),
-		normalizeText: normalizeWhatsAppChannelSendText
-	}),
-	sendTextOnlyErrorPayloads: true,
-	renderPresentation: prepareWhatsAppApprovalPayloadForDelivery,
-	afterDeliverPayload: registerDeliveredWhatsAppApprovalPayload,
-	normalizePayload: ({ payload }) => ({
-		...payload,
-		text: normalizeWhatsAppChannelPayloadText(payload.text)
-	})
-};
-function toWhatsAppMessageSendResult(result, replyToId) {
-	const source = result;
-	const receipt = result.receipt ?? createMessageReceiptFromOutboundResults({
-		results: result.messageId ? [{
-			channel: "whatsapp",
-			messageId: result.messageId,
-			toJid: source.toJid
-		}] : [],
-		kind: "text",
-		...replyToId ? { replyToId } : {}
-	});
-	return {
-		messageId: result.messageId || receipt.primaryPlatformMessageId,
-		receipt
-	};
-}
-const whatsappMessageAdapter = defineChannelMessageAdapter({
-	id: "whatsapp",
-	durableFinal: { capabilities: {
-		text: true,
-		replyTo: true,
-		messageSendingHooks: true
-	} },
-	send: { text: async ({ onDeliveryResult, ...ctx }) => {
-		return toWhatsAppMessageSendResult(await whatsappChannelOutbound.sendText({
-			...ctx,
-			onDeliveryResult: onDeliveryResult ? async (progress) => {
-				await onDeliveryResult(toWhatsAppMessageSendResult(progress, ctx.replyToId));
-			} : void 0
-		}), ctx.replyToId);
-	} }
-});
-//#endregion
-//#region extensions/whatsapp/src/group-intro.ts
-function resolveWhatsAppMentionStripRegexes(ctx) {
-	const selfE164 = (ctx.To ?? "").replace(/^whatsapp:/i, "");
-	if (!selfE164) return [];
-	const escaped = selfE164.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-	return [new RegExp(escaped, "g"), new RegExp(`@${escaped}`, "g")];
-}
-//#endregion
-//#region extensions/whatsapp/src/heartbeat.ts
-async function checkWhatsAppHeartbeatReady(params) {
-	if (params.cfg.channels?.whatsapp?.enabled === false) return {
-		ok: false,
-		reason: "whatsapp-disabled"
-	};
-	const account = resolveWhatsAppAccount({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const authState = await (params.deps?.readWebAuthExistsForDecision ?? readWebAuthExistsForDecision)(account.authDir);
-	if (authState.outcome === "unstable") return {
-		ok: false,
-		reason: WHATSAPP_AUTH_UNSTABLE_CODE
-	};
-	if (!authState.exists) return {
-		ok: false,
-		reason: "whatsapp-not-linked"
-	};
-	if (!(params.deps?.hasActiveWebListener ? params.deps.hasActiveWebListener(account.accountId) : Boolean((await loadWhatsAppChannelRuntime()).getActiveWebListener(account.accountId)))) return {
-		ok: false,
-		reason: "whatsapp-not-running"
-	};
-	return {
-		ok: true,
-		reason: "ok"
-	};
-}
-//#endregion
-//#region extensions/whatsapp/src/session-route.ts
-function resolveWhatsAppOutboundSessionRoute(params) {
-	const normalized = normalizeWhatsAppTarget(params.target);
-	if (!normalized) return null;
-	const isGroup = isWhatsAppGroupJid(normalized);
-	const isNewsletter = isWhatsAppNewsletterJid(normalized);
-	const chatType = isGroup ? "group" : isNewsletter ? "channel" : "direct";
-	const route = buildChannelOutboundSessionRoute({
-		cfg: params.cfg,
-		agentId: params.agentId,
-		channel: "whatsapp",
-		accountId: params.accountId,
-		recipientSessionExact: true,
-		peer: {
-			kind: chatType,
-			id: normalized
-		},
-		chatType,
-		from: normalized,
-		to: normalized
-	});
-	return isGroup ? {
-		...route,
-		sessionKey: resolveWhatsAppGroupSessionKey({
-			sessionKey: route.sessionKey,
-			accountId: params.accountId
-		})
-	} : route;
-}
-//#endregion
-//#region extensions/whatsapp/src/status-issues.ts
-const WHATSAPP_ACCOUNT_STATUS_FIELDS = [
-	"statusState",
-	"linked",
-	"reconnectAttempts",
-	"lastDisconnect",
-	"lastInboundAt",
-	"lastError",
-	"healthState"
-];
-const RECENT_DISCONNECT_WARNING_WINDOW_MS = 900 * 1e3;
-function readLastDisconnect(value) {
-	if (typeof value === "string") {
-		const error = asString(value);
-		return error ? {
-			at: null,
-			error
-		} : null;
-	}
-	if (!isRecord$1(value)) return null;
-	return {
-		at: typeof value.at === "number" ? value.at : null,
-		error: asString(value.error)
-	};
-}
-function isRecentDisconnect(disconnect, now = Date.now()) {
-	if (disconnect?.at == null) return false;
-	return now - disconnect.at <= RECENT_DISCONNECT_WARNING_WINDOW_MS;
-}
-function collectWhatsAppStatusIssues(accounts) {
-	return collectIssuesForEnabledAccounts({
-		accounts,
-		readAccount: (value) => readAccountStatusSnapshot(value, WHATSAPP_ACCOUNT_STATUS_FIELDS),
-		collectIssues: ({ account, accountId, issues }) => {
-			const linked = account.linked === true;
-			const statusState = asString(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);
-			if (statusState === "unstable") {
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "auth",
-					message: "Auth state is still stabilizing.",
-					fix: "Wait a moment for queued credential writes to finish, then retry the command or rerun health."
-				});
-				return;
-			}
-			if (!linked) {
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "auth",
-					message: "Not linked (no WhatsApp Web session).",
-					fix: `Run: ${formatCliCommand("openclaw channels login")} (scan QR on the gateway host).`
-				});
-				return;
-			}
-			if (healthState === "stale") {
-				const staleSuffix = lastInboundAt != null ? ` (last inbound ${Math.max(0, Math.floor((Date.now() - lastInboundAt) / 6e4))}m ago)` : "";
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "runtime",
-					message: `Linked but stale${staleSuffix}${lastError ? `: ${lastError}` : "."}`,
-					fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
-				});
-				return;
-			}
-			if (healthState === "reconnecting" || healthState === "conflict" || healthState === "stopped") {
-				const stateLabel = healthState === "conflict" ? "session conflict" : healthState === "reconnecting" ? "reconnecting" : "stopped";
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "runtime",
-					message: `Linked but ${stateLabel}${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
-					fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
-				});
-				return;
-			}
-			if (healthState === "logged-out") {
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "auth",
-					message: `Linked session logged out${lastError ? `: ${lastError}` : "."}`,
-					fix: `Run: ${formatCliCommand("openclaw channels login")} (scan QR on the gateway host).`
-				});
-				return;
-			}
-			if (linked && running && connected && reconnectAttempts != null && reconnectAttempts > 0 && isRecentDisconnect(lastDisconnect)) {
-				issues.push({
-					channel: "whatsapp",
-					accountId,
-					kind: "runtime",
-					message: `Linked but recently reconnected (reconnectAttempts=${reconnectAttempts})${lastError ? `: ${lastError}` : "."}`,
-					fix: `Watch: ${formatCliCommand("openclaw logs --follow")} and run ${formatCliCommand("openclaw channels status --probe")} if disconnects continue. If it keeps flapping, restart the gateway or relink via channels login.`
-				});
-				return;
-			}
-			if (running && !connected) issues.push({
-				channel: "whatsapp",
-				accountId,
-				kind: "runtime",
-				message: `Linked but disconnected${reconnectAttempts != null ? ` (reconnectAttempts=${reconnectAttempts})` : ""}${lastError ? `: ${lastError}` : "."}`,
-				fix: `Run: ${formatCliCommand("openclaw doctor")} (or restart the gateway). If it persists, relink via channels login and check logs.`
-			});
-		}
-	});
-}
-//#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-DUIkjl6w.js"));
-function resolveWhatsAppTargetInfo(raw) {
-	const normalized = normalizeWhatsAppTarget(raw);
-	if (!normalized) return null;
-	return {
-		to: normalized,
-		chatType: isWhatsAppGroupJid(normalized) ? "group" : isWhatsAppNewsletterJid(normalized) ? "channel" : "direct"
-	};
-}
-function resolveWhatsAppMessageActionTarget(params) {
-	const chatJid = params.args.chatJid;
-	return typeof chatJid === "string" ? normalizeWhatsAppMessagingTarget(chatJid) : void 0;
-}
-const whatsappPlugin = createChatChannelPlugin({
-	pairing: {
-		idLabel: "whatsappSenderId",
-		normalizeAllowEntry: (entry) => normalizeWhatsAppAllowFromEntry(entry) ?? ""
-	},
-	outbound: whatsappChannelOutbound,
-	threading: { scopedAccountReplyToMode: {
-		resolveAccount: (cfg, accountId) => resolveWhatsAppAccount({
-			cfg,
-			accountId
-		}),
-		resolveReplyToMode: (account) => account.replyToMode
-	} },
-	base: {
-		...createWhatsAppPluginBase({
-			groups: {
-				resolveRequireMention: resolveWhatsAppGroupRequireMention,
-				resolveToolPolicy: resolveWhatsAppGroupToolPolicy
-			},
-			setupWizard: whatsappSetupWizardProxy,
-			setup: whatsappSetupAdapter,
-			setupContract: whatsappSetupContract,
-			isConfigured: async (account) => await isWhatsAppAuthConfigured(account.authDir)
-		}),
-		agentTools: () => [createWhatsAppLoginTool()],
-		allowlist: buildDmGroupAccountAllowlistAdapter({
-			channelId: "whatsapp",
-			resolveAccount: resolveWhatsAppAccount,
-			normalize: ({ values }) => formatWhatsAppConfigAllowFromEntries(values),
-			resolveDmAllowFrom: (account) => account.allowFrom,
-			resolveGroupAllowFrom: (account) => account.groupAllowFrom,
-			resolveDmPolicy: (account) => account.dmPolicy,
-			resolveGroupPolicy: (account) => account.groupPolicy
-		}),
-		mentions: { stripRegexes: ({ ctx }) => resolveWhatsAppMentionStripRegexes(ctx) },
-		commands: whatsappCommandPolicy,
-		bindings: {
-			compileConfiguredBinding: ({ conversationId }) => {
-				const normalized = normalizeWhatsAppTarget(conversationId);
-				return normalized ? { conversationId: normalized } : null;
-			},
-			matchInboundConversation: ({ compiledBinding, conversationId }) => {
-				if (normalizeWhatsAppTarget(conversationId) === compiledBinding.conversationId) return {
-					conversationId: compiledBinding.conversationId,
-					matchPriority: 2
-				};
-				return null;
-			}
-		},
-		agentPrompt: { reactionGuidance: ({ cfg, accountId }) => {
-			const level = resolveWhatsAppAgentReactionGuidance({
-				cfg,
-				accountId: accountId ?? void 0
-			});
-			return level ? {
-				level,
-				channelLabel: "WhatsApp"
-			} : void 0;
-		} },
-		messaging: {
-			targetPrefixes: ["whatsapp"],
-			normalizeTarget: normalizeWhatsAppMessagingTarget,
-			resolveOutboundSessionRoute: (params) => resolveWhatsAppOutboundSessionRoute(params),
-			inferTargetChatType: ({ to }) => resolveWhatsAppTargetInfo(to)?.chatType,
-			targetResolver: {
-				looksLikeId: looksLikeWhatsAppTargetId,
-				hint: "<E.164|group JID|newsletter JID>"
-			}
-		},
-		message: whatsappMessageAdapter,
-		directory: {
-			self: async ({ cfg, accountId }) => {
-				const account = resolveWhatsAppAccount({
-					cfg,
-					accountId
-				});
-				const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
-				const id = e164 ?? jid;
-				if (!id) return null;
-				return {
-					kind: "user",
-					id,
-					name: account.name,
-					raw: {
-						e164,
-						jid
-					}
-				};
-			},
-			listPeers: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryPeersFromConfig(params),
-			listGroups: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsFromConfig(params),
-			listGroupsLive: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsLive(params)
-		},
-		actions: {
-			messageActionTargetAliases: { react: {
-				aliases: ["chatJid", "messageId"],
-				deliveryTargetAliases: ["chatJid"],
-				resolveDeliveryTarget: resolveWhatsAppMessageActionTarget
-			} },
-			describeMessageTool: ({ cfg, accountId }) => describeWhatsAppMessageActions({
-				cfg,
-				accountId
-			}),
-			supportsAction: ({ action }) => action === "react" || action === "upload-file",
-			resolveExecutionMode: ({ action }) => action === "react" || action === "upload-file" ? "gateway" : "local",
-			handleAction: async ({ action, params, cfg, accountId, requesterSenderId, mediaAccess, mediaLocalRoots, mediaReadFile, toolContext }) => await (await loadWhatsAppChannelReactAction()).handleWhatsAppMessageAction({
-				action,
-				params,
-				cfg,
-				accountId,
-				requesterSenderId,
-				mediaAccess,
-				mediaLocalRoots,
-				mediaReadFile,
-				toolContext
-			})
-		},
-		approvalCapability: whatsappApprovalCapability,
-		auth: { login: async ({ cfg, accountId, runtime, verbose }) => {
-			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,
-				accountId: accountId ?? void 0,
-				deps
-			}),
-			sendTyping: async ({ cfg, to, accountId }) => {
-				await sendTypingWhatsApp(to, {
-					cfg,
-					...accountId ? { accountId } : {}
-				});
-			}
-		},
-		status: createAsyncComputedAccountStatusAdapter({
-			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID$1, {
-				connected: false,
-				reconnectAttempts: 0,
-				lastConnectedAt: null,
-				lastDisconnect: null,
-				lastInboundAt: null,
-				lastMessageAt: null,
-				lastEventAt: null,
-				busy: false,
-				lastRunActivityAt: null,
-				healthState: "stopped"
-			}),
-			collectStatusIssues: collectWhatsAppStatusIssues,
-			buildChannelSummary: async ({ account, snapshot }) => {
-				const channelRuntime = await loadWhatsAppChannelRuntime();
-				const authDir = account.authDir;
-				const auth = authDir ? await channelRuntime.readWebAuthSnapshot(authDir) : {
-					state: "not-linked",
-					authAgeMs: null,
-					selfId: {
-						e164: null,
-						jid: null,
-						lid: null
-					}
-				};
-				const linked = typeof snapshot.linked === "boolean" ? snapshot.linked : auth.state === "unstable" ? void 0 : auth.state === "linked";
-				const summaryAuthState = auth.state === "unstable" ? auth.state : linked === true ? "linked" : linked === false ? "not-linked" : void 0;
-				const statusState = summaryAuthState === void 0 ? void 0 : summaryAuthState;
-				const configured = auth.state === "unstable" ? typeof snapshot.configured === "boolean" ? snapshot.configured : true : typeof linked === "boolean" ? linked : auth.state === "linked";
-				const authAgeMs = typeof linked === "boolean" && linked ? auth.authAgeMs : null;
-				const self = typeof linked === "boolean" && linked ? auth.selfId : {
-					e164: null,
-					jid: null,
-					lid: null
-				};
-				return {
-					configured,
-					...statusState ? { statusState } : {},
-					...typeof linked === "boolean" ? { linked } : {},
-					authAgeMs,
-					self,
-					running: snapshot.running ?? false,
-					connected: snapshot.connected ?? false,
-					lastConnectedAt: snapshot.lastConnectedAt ?? null,
-					lastDisconnect: snapshot.lastDisconnect ?? null,
-					reconnectAttempts: snapshot.reconnectAttempts,
-					lastInboundAt: snapshot.lastInboundAt ?? snapshot.lastMessageAt ?? null,
-					lastMessageAt: snapshot.lastMessageAt ?? null,
-					lastEventAt: snapshot.lastEventAt ?? null,
-					busy: snapshot.busy ?? false,
-					lastRunActivityAt: snapshot.lastRunActivityAt ?? null,
-					lastError: snapshot.lastError ?? null,
-					healthState: snapshot.healthState ?? void 0,
-					...snapshot.terminalDisconnect ? { terminalDisconnect: snapshot.terminalDisconnect } : {}
-				};
-			},
-			resolveAccountSnapshot: async ({ account, runtime }) => {
-				const authState = await (await loadWhatsAppChannelRuntime()).readWebAuthState(account.authDir);
-				return {
-					accountId: account.accountId,
-					name: account.name,
-					enabled: account.enabled,
-					configured: true,
-					extra: {
-						statusState: authState,
-						...authState === "linked" ? { linked: true } : authState === "not-linked" ? { linked: false } : {},
-						connected: runtime?.connected ?? false,
-						reconnectAttempts: runtime?.reconnectAttempts,
-						lastConnectedAt: runtime?.lastConnectedAt ?? null,
-						lastDisconnect: runtime?.lastDisconnect ?? null,
-						lastInboundAt: runtime?.lastInboundAt ?? runtime?.lastMessageAt ?? null,
-						lastMessageAt: runtime?.lastMessageAt ?? null,
-						lastEventAt: runtime?.lastEventAt ?? null,
-						busy: runtime?.busy ?? false,
-						lastRunActivityAt: runtime?.lastRunActivityAt ?? null,
-						healthState: runtime?.healthState ?? void 0,
-						...runtime?.terminalDisconnect ? { terminalDisconnect: runtime.terminalDisconnect } : {},
-						dmPolicy: account.dmPolicy,
-						allowFrom: account.allowFrom
-					}
-				};
-			},
-			resolveAccountState: ({ configured }) => configured ? "linked" : "not linked",
-			logSelfId: ({ account, runtime, includeChannelPrefix }) => {
-				loadWhatsAppChannelRuntime().then((runtimeExports) => runtimeExports.logWebSelfId(account.authDir, runtime, includeChannelPrefix));
-			}
-		}),
-		gateway: {
-			startAccount: async (ctx) => {
-				const account = ctx.account;
-				const { e164, jid } = (await loadWhatsAppChannelRuntime()).readWebSelfId(account.authDir);
-				const identity = e164 ? e164 : jid ? `jid ${jid}` : "unknown";
-				ctx.log?.info(`[${account.accountId}] starting provider (${identity})`);
-				return (await loadWhatsAppChannelRuntime()).monitorWebChannel(getWhatsAppRuntime().logging.shouldLogVerbose(), void 0, true, void 0, ctx.runtime, ctx.abortSignal, {
-					statusSink: (next) => ctx.setStatus({
-						accountId: ctx.accountId,
-						...next
-					}),
-					accountId: account.accountId,
-					channelRuntime: ctx.channelRuntime
-				});
-			},
-			loginWithQrStart: async ({ accountId, force, timeoutMs, verbose }) => await (await loadWhatsAppChannelRuntime()).startWebLoginWithQr({
-				accountId,
-				force,
-				timeoutMs,
-				verbose
-			}),
-			loginWithQrWait: async ({ accountId, timeoutMs, currentQrDataUrl }) => await (await loadWhatsAppChannelRuntime()).waitForWebLogin({
-				accountId,
-				timeoutMs,
-				currentQrDataUrl
-			}),
-			logoutAccount: async ({ account, runtime }) => {
-				const cleared = await (await loadWhatsAppChannelRuntime()).logoutWeb({
-					authDir: account.authDir,
-					isLegacyAuthDir: account.isLegacyAuthDir,
-					runtime
-				});
-				return {
-					cleared,
-					loggedOut: cleared
-				};
-			}
-		}
-	}
-});
-//#endregion
-export { WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS as n, whatsappPlugin as t };