@openclaw/whatsapp 2026.7.2-beta.2 → 2026.7.2-beta.3

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

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { n as isSelfChatMode } from "./targets-runtime-Bsh0HR9y.js";
 import { n as normalizeE164 } from "./text-runtime-BTGkMN0o.js";
 import { a as getSelfIdentity, o as getSenderIdentity } from "./identity-D7L8LCuH.js";

package/dist/{accounts-CKOFMPf-.js → accounts-ejK8sXPU.js}

@@ -1,11 +1,51 @@
-import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-LiT9wWH9.js";
 import { n as listConfiguredAccountIds, r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { n as hasWebCredsRegularFileSync, r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
 import fs from "node:fs";
 import path from "node:path";
-import { DEFAULT_ACCOUNT_ID, normalizeAccountId, resolveUserPath } from "openclaw/plugin-sdk/account-core";
+import { DEFAULT_ACCOUNT_ID, mergeAccountConfig, normalizeAccountId, resolveAccountEntry, resolveMergedAccountConfig, resolveUserPath } from "openclaw/plugin-sdk/account-core";
 import { resolveOAuthDir } from "openclaw/plugin-sdk/state-paths";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/whatsapp/src/account-config.ts
+function resolveWhatsAppDefaultAccountSharedConfig(cfg) {
+	const defaultAccount = resolveAccountEntry(cfg.channels?.whatsapp?.accounts, DEFAULT_ACCOUNT_ID);
+	if (!defaultAccount) return;
+	const { enabled: _ignoredEnabled, name: _ignoredName, authDir: _ignoredAuthDir, selfChatMode: _ignoredSelfChatMode, ...sharedDefaults } = defaultAccount;
+	return sharedDefaults;
+}
+function resolveWhatsAppAccountConfigForTest(cfg, accountId) {
+	return resolveAccountEntry(cfg.channels?.whatsapp?.accounts, accountId);
+}
+function resolveMergedNamedWhatsAppAccountConfig(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountConfig = resolveWhatsAppAccountConfigForTest(params.cfg, params.accountId);
+	return {
+		...mergeAccountConfig({
+			channelConfig: rootCfg,
+			accountConfig: void 0,
+			omitKeys: ["defaultAccount"]
+		}),
+		...resolveWhatsAppDefaultAccountSharedConfig(params.cfg),
+		...accountConfig
+	};
+}
+function resolveMergedWhatsAppAccountConfig(params) {
+	const rootCfg = params.cfg.channels?.whatsapp;
+	const accountId = params.accountId?.trim() || rootCfg?.defaultAccount || DEFAULT_ACCOUNT_ID;
+	const base = resolveMergedAccountConfig({
+		channelConfig: rootCfg,
+		accounts: rootCfg?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"]
+	});
+	return {
+		accountId,
+		...accountId === DEFAULT_ACCOUNT_ID ? base : resolveMergedNamedWhatsAppAccountConfig({
+			cfg: params.cfg,
+			accountId
+		})
+	};
+}
+//#endregion
 //#region extensions/whatsapp/src/accounts.ts
 const DEFAULT_WHATSAPP_MEDIA_MAX_MB = 50;
 function listWhatsAppAuthDirs(cfg) {
@@ -110,4 +150,4 @@ function listEnabledWhatsAppAccounts(cfg) {
 	})).filter((account) => account.enabled);
 }
 //#endregion
-export { resolveWhatsAppAccount as a, listWhatsAppAuthDirs as i, hasAnyWhatsAppAuth as n, resolveWhatsAppAuthDir as o, listEnabledWhatsAppAccounts as r, resolveWhatsAppMediaMaxBytes as s, DEFAULT_WHATSAPP_MEDIA_MAX_MB as t };
+export { resolveWhatsAppAccount as a, resolveMergedWhatsAppAccountConfig as c, listWhatsAppAuthDirs as i, hasAnyWhatsAppAuth as n, resolveWhatsAppAuthDir as o, listEnabledWhatsAppAccounts as r, resolveWhatsAppMediaMaxBytes as s, DEFAULT_WHATSAPP_MEDIA_MAX_MB as t };

package/dist/action-runtime-api.js

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

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

@@ -1,6 +1,6 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-BR97fAbB.js";
-import { r as sendReactionWhatsApp, u as resolveWhatsAppReactionLevel } from "./send-D9Ydnn4o.js";
+import { r as sendReactionWhatsApp, u as resolveWhatsAppReactionLevel } from "./send-SB-4JrVZ.js";
 import { ToolAuthorizationError, createActionGate, jsonResult, readReactionParams, readStringParam } from "openclaw/plugin-sdk/channel-actions";
 //#region extensions/whatsapp/src/action-runtime-target-auth.ts
 function resolveAuthorizedWhatsAppOutboundTarget(params) {

package/dist/action-runtime.runtime.js

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

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

@@ -1,5 +1,5 @@
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.js";
+import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-9mEeAvu1.js";
 //#region extensions/whatsapp/src/active-listener.ts
 function resolveWebAccountId(params) {
 	return (params.accountId ?? "").trim() || resolveDefaultWhatsAppAccountId(params.cfg);

package/dist/api.js

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

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

@@ -1,10 +1,10 @@
+import "./accounts-ejK8sXPU.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import "./accounts-CKOFMPf-.js";
 import { s as normalizeWhatsAppMessagingTarget } from "./normalize-target-DSZnHkKF.js";
-import { i as sendTypingWhatsApp, t as sendMessageWhatsApp } from "./send-D9Ydnn4o.js";
+import { i as sendTypingWhatsApp, t as sendMessageWhatsApp } from "./send-SB-4JrVZ.js";
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import "./normalize-C-Z16y7Q.js";
-import { i as unregisterWhatsAppApprovalReactionTarget, r as registerWhatsAppApprovalReactionTarget } from "./approval-reactions-BGQoz25s.js";
+import { i as unregisterWhatsAppApprovalReactionTarget, r as registerWhatsAppApprovalReactionTarget } from "./approval-reactions-CrZFAyf-.js";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { buildChannelApprovalNativeTargetKey } from "openclaw/plugin-sdk/approval-native-runtime";

package/dist/{approval-reactions-BGQoz25s.js → approval-reactions-CrZFAyf-.js}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { t as getOptionalWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth } from "./group-session-key-CLTZeH_F.js";
+import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth } from "./group-session-key-Dh8WZun_.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { createApprovalReactionTargetStore, listApprovalReactionBindings, resolveTypedApprovalReactionTarget } from "openclaw/plugin-sdk/approval-reaction-runtime";
 //#region extensions/whatsapp/src/approval-reactions.ts

package/dist/call-tool-api.js

@@ -1,5 +1,5 @@
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
-import { n as getWhatsAppConnectionController } from "./connection-controller-runtime-context-CbTsqmPT.js";
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
+import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-9mEeAvu1.js";
 import { o as resolveJidToE164 } from "./targets-runtime-Bsh0HR9y.js";
 import { createActionGate, stringEnum } from "openclaw/plugin-sdk/channel-actions";
 import path from "node:path";

package/dist/{channel-DbadDUDD.js → channel-B2I4Opzb.js}

@@ -1,16 +1,16 @@
+import { a as resolveWhatsAppAccount } from "./accounts-ejK8sXPU.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CKOFMPf-.js";
 import { c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, n as isWhatsAppNewsletterJid, o as normalizeWhatsAppAllowFromEntry, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
 import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-BR97fAbB.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-D9Ydnn4o.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-SB-4JrVZ.js";
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import "./normalize-C-Z16y7Q.js";
 import { s as toWhatsappJid } from "./targets-runtime-Bsh0HR9y.js";
 import "./text-runtime-BTGkMN0o.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-CLTZeH_F.js";
+import { c as getWhatsAppApprovalApprovers, l as whatsappApprovalAuth, s as lookupInboundMessageMetaForTarget, t as resolveWhatsAppGroupSessionKey } from "./group-session-key-Dh8WZun_.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, r as loadWhatsAppChannelRuntime, s as formatWhatsAppConfigAllowFromEntries, t as whatsappSetupAdapter } from "./setup-core-3aSOoK2T.js";
+import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, r as loadWhatsAppChannelRuntime, s as formatWhatsAppConfigAllowFromEntries, t as whatsappSetupAdapter } from "./setup-core-BbIgEl2M.js";
 import { f as readWebAuthExistsForDecision, n as WHATSAPP_AUTH_UNSTABLE_CODE } from "./auth-store-BQi9pZqQ.js";
 import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-CAMTrs2U.js";
 import { createActionGate as createActionGate$1 } from "openclaw/plugin-sdk/channel-actions";
@@ -30,6 +30,7 @@ import { createLazyChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-s
 import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createNativeApprovalChannelRouteGates, createNativeApprovalForwardingFallbackSuppressor } 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 { chunkText } from "openclaw/plugin-sdk/reply-chunking";
 import { attachChannelToResult, createAttachedChannelResultAdapter } from "openclaw/plugin-sdk/channel-send-result";
 //#region extensions/whatsapp/src/approval-native.ts
@@ -224,7 +225,7 @@ const whatsappApprovalCapability = createChannelApprovalCapability({
 			approvalKind,
 			request
 		}),
-		load: async () => (await import("./approval-handler.runtime-CBiGQuZ5.js")).whatsappApprovalNativeRuntime
+		load: async () => (await import("./approval-handler.runtime-BO1oJ-b8.js")).whatsappApprovalNativeRuntime
 	})
 });
 //#endregion
@@ -390,7 +391,8 @@ function createWhatsAppOutboundBase({ chunker, sendMessageWhatsApp, sendPollWhat
 }
 //#endregion
 //#region extensions/whatsapp/src/channel-outbound.ts
-const loadWhatsAppApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-BGQoz25s.js").then((n) => n.t));
+const loadWhatsAppApprovalReactionsModule = createLazyRuntimeModule(() => import("./approval-reactions-CrZFAyf-.js").then((n) => n.t));
+const loadWhatsAppQuestionReactionsModule = createLazyRuntimeModule(() => import("./question-reactions-C0qJ6wGA.js").then((n) => n.n));
 function normalizeWhatsAppChannelPayloadText(text) {
 	return normalizeWhatsAppPayloadTextPreservingIndentation(text);
 }
@@ -399,12 +401,18 @@ function normalizeWhatsAppChannelSendText(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 = {
@@ -657,8 +665,8 @@ function collectWhatsAppStatusIssues(accounts) {
 }
 //#endregion
 //#region extensions/whatsapp/src/channel.ts
-const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-CLBQrjtC.js").then((n) => n.t));
-const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-PoRWfP9x.js"));
+const loadWhatsAppDirectoryConfig = createLazyRuntimeModule(() => import("./directory-config-BZ775eGX.js").then((n) => n.t));
+const loadWhatsAppChannelReactAction = createLazyRuntimeModule(() => import("./channel-react-action-CPRQE-s3.js"));
 function resolveWhatsAppTargetInfo(raw) {
 	const normalized = normalizeWhatsAppTarget(raw);
 	if (!normalized) return null;
@@ -758,7 +766,8 @@ const whatsappPlugin = createChatChannelPlugin({
 				};
 			},
 			listPeers: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryPeersFromConfig(params),
-			listGroups: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsFromConfig(params)
+			listGroups: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsFromConfig(params),
+			listGroupsLive: async (params) => (await loadWhatsAppDirectoryConfig()).listWhatsAppDirectoryGroupsLive(params)
 		},
 		actions: {
 			describeMessageTool: ({ cfg, accountId }) => describeWhatsAppMessageActions({

package/dist/channel-plugin-api.js

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

package/dist/{channel-react-action-PoRWfP9x.js → channel-react-action-CPRQE-s3.js}

@@ -1,7 +1,7 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CKOFMPf-.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-ejK8sXPU.js";
 import { c as normalizeWhatsAppTarget, t as isWhatsAppGroupJid } from "./normalize-target-DSZnHkKF.js";
-import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-Bf-12TIH.js";
-import { t as sendMessageWhatsApp } from "./send-D9Ydnn4o.js";
+import { r as resolveAuthorizedWhatsAppOutboundTarget, t as handleWhatsAppAction } from "./action-runtime-p0V390gA.js";
+import { t as sendMessageWhatsApp } from "./send-SB-4JrVZ.js";
 import "./normalize-C-Z16y7Q.js";
 import { jsonResult, readStringOrNumberParam, readStringParam as readStringParam$1, resolveReactionMessageId } from "openclaw/plugin-sdk/channel-actions";
 import { readBooleanParam } from "openclaw/plugin-sdk/boolean-param";

package/dist/{channel.runtime-BDDy4Lhz.js → channel.runtime-CjkhQzk8.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-BQi9pZqQ.js";
-import { t as getActiveWebListener$1 } from "./active-listener-5kHap439.js";
-import { t as monitorWebChannel$1 } from "./monitor-BZ8QvCeV.js";
-import { t as loginWeb$1 } from "./login-DGIoToX8.js";
-import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-CiKGdNJv.js";
+import { t as getActiveWebListener$1 } from "./active-listener-BbdlXooT.js";
+import { t as monitorWebChannel$1 } from "./monitor-_jqDKBXj.js";
+import { t as loginWeb$1 } from "./login-ifOXCBjo.js";
+import { whatsappSetupWizard as whatsappSetupWizard$1 } from "./setup-surface-DhnXEZir.js";
 //#region extensions/whatsapp/src/channel.runtime.ts
 function getActiveWebListener(...args) {
 	return getActiveWebListener$1(...args);

package/dist/{channel.setup-BZ-po8fg.js → channel.setup-BMWE9LmN.js}

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, t as whatsappSetupAdapter } from "./setup-core-3aSOoK2T.js";
+import { a as resolveWhatsAppGroupRequireMention, i as whatsappSetupWizardProxy, n as createWhatsAppPluginBase, o as resolveWhatsAppGroupToolPolicy, t as whatsappSetupAdapter } from "./setup-core-BbIgEl2M.js";
 import { t as detectWhatsAppLegacyStateMigrations } from "./state-migrations-CAMTrs2U.js";
 //#region extensions/whatsapp/src/channel.setup.ts
 async function isWhatsAppAuthConfigured(account) {

package/dist/{connection-controller-C1rwfWb4.js → connection-controller-HGaffeFb.js}

@@ -1,8 +1,8 @@
 import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-CbTsqmPT.js";
-import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError } from "./auth-store-BQi9pZqQ.js";
+import { n as WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY, t as WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY } from "./connection-controller-runtime-context-9mEeAvu1.js";
+import { c as logoutWeb, f as readWebAuthExistsForDecision, r as WhatsAppAuthUnstableError, w as waitForCredsSaveQueueWithTimeout } from "./auth-store-BQi9pZqQ.js";
 import { c as resolveComparableIdentity } from "./identity-D7L8LCuH.js";
-import { i as DEFAULT_WHATSAPP_SOCKET_TIMING, r as waitForWaConnection, t as createWaSocket } from "./session-mxWFn0eS.js";
+import { a as waitForWaConnection, m as acquireWhatsAppGatewayConnectionOwner, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, t as closeWhatsAppSocketAndWait } from "./socket-close-jNGyZY4T.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";
@@ -89,17 +89,28 @@ function createLiveConnection(params) {
 		openedAfterRecentInbound: params.openedAfterRecentInbound,
 		backgroundTasks: /* @__PURE__ */ new Set(),
 		closePromise,
-		resolveClose: resolveClosePromise
+		resolveClose: resolveClosePromise,
+		socketClosed: false
 	};
 }
+async function closeWebSocketBestEffort(sock) {
+	try {
+		await sock.ws?.close?.();
+	} catch {}
+}
 function closeWaSocket(sock) {
 	try {
 		if (typeof sock?.end === "function") {
-			sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"));
+			Promise.resolve(sock.end(/* @__PURE__ */ new Error("OpenClaw WhatsApp socket close"))).catch(async () => await closeWebSocketBestEffort(sock));
 			return;
 		}
-		sock?.ws?.close?.();
-	} catch {}
+		if (sock) closeWebSocketBestEffort(sock);
+	} catch {
+		if (sock) closeWebSocketBestEffort(sock);
+	}
+}
+function stoppedControllerError() {
+	return /* @__PURE__ */ new Error("WhatsApp connection controller is shutting down");
 }
 function closeWaSocketSoon(sock, delayMs = 500) {
 	setTimeout(() => {
@@ -229,6 +240,15 @@ var WhatsAppConnectionController = class {
 		this.disconnectRetryController = new AbortController();
 		this.current = null;
 		this.runtimeContextLease = null;
+		this.pendingOwnerContextLease = null;
+		this.connectionOwnerLease = null;
+		this.retainedOwnerReleaseLease = null;
+		this.connectionOwnerLeasePromise = null;
+		this.connectionSetupPromise = null;
+		this.pendingSocketCleanup = null;
+		this.shuttingDown = false;
+		this.ownerAcquireAbortController = new AbortController();
+		this.setupAbortController = new AbortController();
 		this.reconnectAttempts = 0;
 		this.lastHandledInboundAt = null;
 		this.accountId = params.accountId;
@@ -249,11 +269,17 @@ var WhatsAppConnectionController = class {
 			...params.socketTiming
 		};
 		this.socketRef = { current: null };
-		this.abortPromise = params.abortSignal && new Promise((resolve) => {
-			params.abortSignal?.addEventListener("abort", () => resolve("aborted"), { once: true });
+		const abortSignal = params.abortSignal;
+		if (abortSignal) this.abortPromise = new Promise((resolve) => {
+			const stop = () => {
+				resolve("aborted");
+				this.stopDisconnectRetries();
+				this.ownerAcquireAbortController.abort(abortSignal.reason);
+				this.setupAbortController.abort(abortSignal.reason);
+			};
+			if (abortSignal.aborted) stop();
+			else abortSignal.addEventListener("abort", stop, { once: true });
 		});
-		if (params.abortSignal?.aborted) this.stopDisconnectRetries();
-		else params.abortSignal?.addEventListener("abort", () => this.stopDisconnectRetries(), { once: true });
 	}
 	getActiveListener() {
 		return this.current?.listener ?? null;
@@ -322,7 +348,23 @@ var WhatsAppConnectionController = class {
 		this.current.unregisterUnhandled = unregister;
 	}
 	async openConnection(params) {
+		if (this.shuttingDown) throw stoppedControllerError();
+		if (this.connectionSetupPromise) throw new Error("WhatsApp connection setup is already in progress");
+		const setupPromise = this.openConnectionOwned(params);
+		this.connectionSetupPromise = setupPromise;
+		try {
+			return await setupPromise;
+		} finally {
+			if (this.connectionSetupPromise === setupPromise) this.connectionSetupPromise = null;
+		}
+	}
+	async openConnectionOwned(params) {
+		await this.ensureConnectionOwnership();
+		this.throwIfSetupStopped();
+		await this.finishPendingSocketCleanup();
+		this.throwIfSetupStopped();
 		if (this.current) await this.closeCurrentConnection();
+		this.throwIfSetupStopped();
 		let sock = null;
 		let connection = null;
 		try {
@@ -332,8 +374,9 @@ var WhatsAppConnectionController = class {
 				...params.getMessage ? { getMessage: params.getMessage } : {},
 				...params.cachedGroupMetadata ? { cachedGroupMetadata: params.cachedGroupMetadata } : {}
 			});
-			await waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs });
-			const channelRuntime = getWhatsAppRuntime().channel;
+			this.throwIfSetupStopped();
+			await this.waitForSetupStep(waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs }));
+			this.throwIfSetupStopped();
 			this.socketRef.current = sock;
 			connection = createLiveConnection({
 				connectionId: params.connectionId,
@@ -341,16 +384,24 @@ var WhatsAppConnectionController = class {
 				listener: {},
 				openedAfterRecentInbound: this.isOpeningAfterRecentInbound()
 			});
-			const listener = await params.createListener({
+			const listenerTask = params.createListener({
 				sock,
 				connection
 			});
+			let listener;
+			try {
+				listener = await this.waitForSetupStep(listenerTask);
+			} catch (error) {
+				if (this.setupAbortController.signal.aborted) listenerTask.then((lateListener) => lateListener.close?.()).catch(() => {});
+				throw error;
+			}
 			connection.listener = listener;
+			this.throwIfSetupStopped();
 			this.current = connection;
 			connection.unregisterTransportActivity = this.attachTransportActivityListener(sock);
 			const previousRuntimeContextLease = this.runtimeContextLease;
 			this.runtimeContextLease = registerChannelRuntimeContext({
-				channelRuntime,
+				channelRuntime: getWhatsAppRuntime().channel,
 				channelId: "whatsapp",
 				accountId: this.accountId,
 				capability: WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY,
@@ -358,16 +409,38 @@ var WhatsAppConnectionController = class {
 				abortSignal: this.abortSignal
 			});
 			previousRuntimeContextLease?.dispose();
+			this.pendingOwnerContextLease?.dispose();
+			this.pendingOwnerContextLease = null;
 			this.startTimers(connection, {
 				onHeartbeat: params.onHeartbeat,
 				onWatchdogTimeout: params.onWatchdogTimeout
 			});
 			return connection;
 		} catch (err) {
-			if (this.socketRef.current === sock) this.socketRef.current = null;
-			closeWaSocket(sock);
-			if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
-			connection?.unregisterTransportActivity?.();
+			try {
+				if (connection && this.current === connection) await this.closeCurrentConnection();
+				else {
+					try {
+						await connection?.listener.close?.();
+					} catch {}
+					if (this.socketRef.current === sock) this.socketRef.current = null;
+					if (sock) {
+						const cleanup = connection ?? {
+							sock,
+							socketClosed: false
+						};
+						await this.finishSocketCleanup(cleanup);
+					}
+					if (connection?.unregisterUnhandled) connection.unregisterUnhandled();
+					connection?.unregisterTransportActivity?.();
+				}
+			} catch (closeError) {
+				if (sock && (!connection || this.current !== connection)) this.pendingSocketCleanup = connection ?? {
+					sock,
+					socketClosed: false
+				};
+				throw new AggregateError([err, closeError], "WhatsApp connection setup and close failed", { cause: err });
+			}
 			throw err;
 		}
 	}
@@ -460,6 +533,7 @@ var WhatsAppConnectionController = class {
 		const connection = this.current;
 		if (!connection) return;
 		this.current = null;
+		this.pendingSocketCleanup = connection;
 		if (this.socketRef.current === connection.sock) this.socketRef.current = null;
 		connection.unregisterUnhandled?.();
 		connection.unregisterTransportActivity?.();
@@ -472,16 +546,103 @@ var WhatsAppConnectionController = class {
 		try {
 			await connection.listener.close?.();
 		} catch {}
-		closeWaSocket(connection.sock);
+		await this.finishSocketCleanup(connection);
+		if (this.pendingSocketCleanup === connection) this.pendingSocketCleanup = null;
 	}
 	async waitBeforeRetry(delayMs) {
 		await this.sleep(delayMs, this.abortSignal);
 	}
 	async shutdown() {
+		this.shuttingDown = true;
+		const stoppedError = stoppedControllerError();
+		this.ownerAcquireAbortController.abort(stoppedError);
+		this.setupAbortController.abort(stoppedError);
 		this.stopDisconnectRetries();
+		await this.connectionSetupPromise?.catch(() => {});
+		await this.connectionOwnerLeasePromise?.catch(() => {});
 		await this.closeCurrentConnection();
-		this.runtimeContextLease?.dispose();
-		this.runtimeContextLease = null;
+		await this.finishPendingSocketCleanup();
+		try {
+			this.runtimeContextLease?.dispose();
+		} finally {
+			this.runtimeContextLease = null;
+			try {
+				this.pendingOwnerContextLease?.dispose();
+			} finally {
+				this.pendingOwnerContextLease = null;
+				if (this.connectionOwnerLease) {
+					await this.connectionOwnerLease.release();
+					this.connectionOwnerLease = null;
+				}
+				if (this.retainedOwnerReleaseLease) {
+					await this.retainedOwnerReleaseLease.release();
+					this.retainedOwnerReleaseLease = null;
+				}
+			}
+		}
+	}
+	async finishSocketCleanup(cleanup) {
+		if (!cleanup.socketClosed) {
+			await closeWhatsAppSocketAndWait(cleanup.sock, "OpenClaw WhatsApp socket close");
+			cleanup.socketClosed = true;
+		}
+		if (await waitForCredsSaveQueueWithTimeout(this.authDir) === "timed_out") throw new Error("WhatsApp credential persistence did not drain before owner release");
+	}
+	async finishPendingSocketCleanup() {
+		const cleanup = this.pendingSocketCleanup;
+		if (!cleanup) return;
+		await this.finishSocketCleanup(cleanup);
+		if (this.pendingSocketCleanup === cleanup) this.pendingSocketCleanup = null;
+	}
+	throwIfSetupStopped() {
+		if (this.shuttingDown || this.setupAbortController.signal.aborted) throw stoppedControllerError();
+	}
+	async waitForSetupStep(task) {
+		this.throwIfSetupStopped();
+		const signal = this.setupAbortController.signal;
+		let onAbort;
+		const aborted = new Promise((_resolve, reject) => {
+			onAbort = () => reject(stoppedControllerError());
+			signal.addEventListener("abort", onAbort, { once: true });
+		});
+		try {
+			return await Promise.race([task, aborted]);
+		} finally {
+			if (onAbort) signal.removeEventListener("abort", onAbort);
+		}
+	}
+	async ensureConnectionOwnership() {
+		if (this.retainedOwnerReleaseLease) {
+			await this.retainedOwnerReleaseLease.release();
+			this.retainedOwnerReleaseLease = null;
+		}
+		if (this.connectionOwnerLease) return;
+		if (!this.connectionOwnerLeasePromise) this.connectionOwnerLeasePromise = (async () => {
+			const ownerLease = await acquireWhatsAppGatewayConnectionOwner(this.authDir, this.ownerAcquireAbortController.signal);
+			try {
+				if (this.shuttingDown) throw stoppedControllerError();
+				this.pendingOwnerContextLease = registerChannelRuntimeContext({
+					channelRuntime: getWhatsAppRuntime().channel,
+					channelId: "whatsapp",
+					accountId: this.accountId,
+					capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY,
+					context: true,
+					abortSignal: this.abortSignal
+				});
+				this.connectionOwnerLease = ownerLease;
+			} catch (error) {
+				try {
+					await ownerLease.release();
+				} catch (releaseError) {
+					this.retainedOwnerReleaseLease = ownerLease;
+					throw new AggregateError([error, releaseError], "WhatsApp connection ownership setup and release failed", { cause: error });
+				}
+				throw error;
+			}
+		})().finally(() => {
+			this.connectionOwnerLeasePromise = null;
+		});
+		await this.connectionOwnerLeasePromise;
 	}
 	startTimers(connection, hooks) {
 		if (!this.keepAlive) return;

package/dist/{connection-controller-runtime-context-CbTsqmPT.js → connection-controller-runtime-context-9mEeAvu1.js}

@@ -2,6 +2,7 @@ import { t as getOptionalWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import { getChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 //#region extensions/whatsapp/src/connection-controller-runtime-context.ts
 const WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY = "connection-controller";
+const WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY = "connection-owner-pending";
 function getWhatsAppConnectionController(accountId) {
 	return getChannelRuntimeContext({
 		channelRuntime: getOptionalWhatsAppRuntime()?.channel,
@@ -10,5 +11,13 @@ function getWhatsAppConnectionController(accountId) {
 		capability: "connection-controller"
 	}) ?? null;
 }
+function hasPendingWhatsAppConnectionOwner(accountId) {
+	return Boolean(getChannelRuntimeContext({
+		channelRuntime: getOptionalWhatsAppRuntime()?.channel,
+		channelId: "whatsapp",
+		accountId,
+		capability: WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY
+	}));
+}
 //#endregion
-export { getWhatsAppConnectionController as n, WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY as t };
+export { hasPendingWhatsAppConnectionOwner as i, WHATSAPP_CONNECTION_OWNER_PENDING_CAPABILITY as n, getWhatsAppConnectionController as r, WHATSAPP_CONNECTION_CONTROLLER_CAPABILITY as t };

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-DazDX3RB.js";
+import { a as resolveWhatsAppRuntimeGroupPolicy$1, n as testing } from "./access-control-tjy_em01.js";
 //#region extensions/whatsapp/contract-api.ts
 const canonicalizeLegacySessionKey = canonicalizeLegacySessionKey$1;
 const isLegacyGroupSessionKey = isLegacyGroupSessionKey$1;