@openclaw/whatsapp 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/accounts-BX2fZUyR.js

@@ -0,0 +1,152 @@
+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-W6B3EMZ8.js";
+import fs from "node:fs";
+import path from "node:path";
+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) {
+	const oauthDir = resolveOAuthDir();
+	const whatsappDir = path.join(oauthDir, "whatsapp");
+	const authDirs = /* @__PURE__ */ new Set([oauthDir, path.join(whatsappDir, DEFAULT_ACCOUNT_ID)]);
+	const accountIds = listConfiguredAccountIds(cfg);
+	for (const accountId of accountIds) authDirs.add(resolveWhatsAppAuthDir({
+		cfg,
+		accountId
+	}).authDir);
+	try {
+		const entries = fs.readdirSync(whatsappDir, { withFileTypes: true });
+		for (const entry of entries) {
+			if (!entry.isDirectory()) continue;
+			authDirs.add(path.join(whatsappDir, entry.name));
+		}
+	} catch {}
+	return Array.from(authDirs);
+}
+function hasAnyWhatsAppAuth(cfg) {
+	return listWhatsAppAuthDirs(cfg).some((authDir) => hasWebCredsSync(authDir));
+}
+function resolveDefaultAuthDir(accountId) {
+	return path.join(resolveOAuthDir(), "whatsapp", normalizeAccountId(accountId));
+}
+function resolveLegacyAuthDir() {
+	return resolveOAuthDir();
+}
+function legacyAuthExists(authDir) {
+	return hasWebCredsRegularFileSync(authDir);
+}
+function resolveWhatsAppAuthDir(params) {
+	const accountId = params.accountId.trim() || DEFAULT_ACCOUNT_ID;
+	const configured = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId
+	})?.authDir?.trim();
+	if (configured) return {
+		authDir: resolveUserPath(configured),
+		isLegacy: false
+	};
+	const defaultDir = resolveDefaultAuthDir(accountId);
+	if (accountId === DEFAULT_ACCOUNT_ID) {
+		const legacyDir = resolveLegacyAuthDir();
+		if (legacyAuthExists(legacyDir) && !legacyAuthExists(defaultDir)) return {
+			authDir: legacyDir,
+			isLegacy: true
+		};
+	}
+	return {
+		authDir: defaultDir,
+		isLegacy: false
+	};
+}
+function resolveWhatsAppAccount(params) {
+	const merged = resolveMergedWhatsAppAccountConfig({
+		cfg: params.cfg,
+		accountId: params.accountId?.trim() || resolveDefaultWhatsAppAccountId(params.cfg)
+	});
+	const accountId = merged.accountId;
+	const enabled = merged.enabled !== false;
+	const { authDir, isLegacy } = resolveWhatsAppAuthDir({
+		cfg: params.cfg,
+		accountId
+	});
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		sendReadReceipts: merged.sendReadReceipts ?? true,
+		messagePrefix: merged.responsePrefix,
+		defaultTo: merged.defaultTo,
+		authDir,
+		isLegacyAuthDir: isLegacy,
+		selfChatMode: merged.selfChatMode,
+		dmPolicy: merged.dmPolicy,
+		allowFrom: merged.allowFrom,
+		groupAllowFrom: merged.groupAllowFrom,
+		groupPolicy: merged.groupPolicy,
+		mentionPatterns: merged.mentionPatterns,
+		historyLimit: merged.historyLimit,
+		textChunkLimit: merged.textChunkLimit,
+		streaming: merged.streaming,
+		mediaMaxMb: merged.mediaMaxMb,
+		ackReaction: merged.ackReaction,
+		reactionLevel: merged.reactionLevel,
+		groups: merged.groups,
+		direct: merged.direct,
+		replyToMode: merged.replyToMode
+	};
+}
+function resolveWhatsAppMediaMaxBytes(account) {
+	const mediaMaxMb = typeof account.mediaMaxMb === "number" && account.mediaMaxMb > 0 ? account.mediaMaxMb : 50;
+	return Math.floor(mediaMaxMb * 1024 * 1024);
+}
+function listEnabledWhatsAppAccounts(cfg) {
+	return listAccountIds(cfg).map((accountId) => resolveWhatsAppAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+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-B4e3XFOY.js

@@ -0,0 +1,73 @@
+import { a as resolveWhatsAppAccount } from "./accounts-BX2fZUyR.js";
+import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-1GqbT1uX.js";
+import { _ as resolveWhatsAppReactionLevel, r as sendReactionWhatsApp } from "./send-prK8F7Vj.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) {
+	const account = resolveWhatsAppAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	const resolution = resolveWhatsAppOutboundTarget({
+		to: params.chatJid,
+		allowFrom: account.allowFrom ?? [],
+		mode: "implicit"
+	});
+	if (!resolution.ok) throw new ToolAuthorizationError(`WhatsApp ${params.actionLabel} blocked: chatJid "${params.chatJid}" is not in the configured allowFrom list for account "${account.accountId}".`);
+	return {
+		to: resolution.to,
+		accountId: account.accountId
+	};
+}
+//#endregion
+//#region extensions/whatsapp/src/action-runtime.ts
+const whatsAppActionRuntime = {
+	resolveAuthorizedWhatsAppOutboundTarget,
+	sendReactionWhatsApp
+};
+async function handleWhatsAppAction(params, cfg) {
+	const action = readStringParam(params, "action", { required: true });
+	const whatsAppConfig = cfg.channels?.whatsapp;
+	const isActionEnabled = createActionGate(whatsAppConfig?.actions);
+	if (action === "react") {
+		const accountId = readStringParam(params, "accountId");
+		if (!whatsAppConfig) throw new Error("WhatsApp reactions are disabled.");
+		if (!isActionEnabled("reactions")) throw new Error("WhatsApp reactions are disabled.");
+		const reactionLevelInfo = resolveWhatsAppReactionLevel({
+			cfg,
+			accountId: accountId ?? void 0
+		});
+		if (!reactionLevelInfo.agentReactionsEnabled) throw new Error(`WhatsApp agent reactions disabled (reactionLevel="${reactionLevelInfo.level}"). Set channels.whatsapp.reactionLevel to "minimal" or "extensive" to enable.`);
+		const chatJid = readStringParam(params, "chatJid", { required: true });
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a WhatsApp reaction." });
+		const participant = readStringParam(params, "participant");
+		const fromMeRaw = params.fromMe;
+		const fromMe = typeof fromMeRaw === "boolean" ? fromMeRaw : void 0;
+		const resolved = whatsAppActionRuntime.resolveAuthorizedWhatsAppOutboundTarget({
+			cfg,
+			chatJid,
+			accountId,
+			actionLabel: "reaction"
+		});
+		const resolvedEmoji = remove ? "" : emoji;
+		await whatsAppActionRuntime.sendReactionWhatsApp(resolved.to, messageId, resolvedEmoji, {
+			verbose: false,
+			fromMe,
+			participant: participant ?? void 0,
+			accountId: resolved.accountId,
+			cfg
+		});
+		if (!remove && !isEmpty) return jsonResult({
+			ok: true,
+			added: emoji
+		});
+		return jsonResult({
+			ok: true,
+			removed: true
+		});
+	}
+	throw new Error(`Unsupported WhatsApp action: ${action}`);
+}
+//#endregion
+export { whatsAppActionRuntime as n, resolveAuthorizedWhatsAppOutboundTarget as r, handleWhatsAppAction as t };

package/dist/action-runtime-api.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-B2bNDUwE.js";
+import { t as handleWhatsAppAction } from "./action-runtime-B4e3XFOY.js";
 export { handleWhatsAppAction };

package/dist/action-runtime.runtime.js

@@ -1,2 +1,2 @@
-import { t as handleWhatsAppAction } from "./action-runtime-B2bNDUwE.js";
+import { t as handleWhatsAppAction } from "./action-runtime-B4e3XFOY.js";
 export { handleWhatsAppAction };

package/dist/agent-tools-login-BjRpD-JQ.js

@@ -0,0 +1,88 @@
+import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
+import "./login-qr-api.js";
+import { optionalPositiveIntegerSchema, readPositiveIntegerParam } from "openclaw/plugin-sdk/channel-actions";
+import { hasNonEmptyString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { Type } from "typebox";
+//#region extensions/whatsapp/src/agent-tools-login.ts
+const QR_DATA_URL_MAX_LENGTH = 16384;
+function readLoginStringPreservingWhitespace(value) {
+	return hasNonEmptyString(value) ? value : void 0;
+}
+function createWhatsAppLoginTool() {
+	return {
+		label: "WhatsApp Login",
+		name: "whatsapp_login",
+		description: "Generate a WhatsApp QR code for linking, or wait for the scan to complete.",
+		parameters: Type.Object({
+			action: Type.Enum(["start", "wait"], { type: "string" }),
+			timeoutMs: optionalPositiveIntegerSchema(),
+			force: Type.Optional(Type.Boolean()),
+			accountId: Type.Optional(Type.String()),
+			currentQrDataUrl: Type.Optional(Type.String({
+				maxLength: QR_DATA_URL_MAX_LENGTH,
+				pattern: "^data:image/png;base64,.+$"
+			}))
+		}),
+		execute: async (_toolCallId, args) => {
+			const renderQrReply = (params) => {
+				return {
+					content: [{
+						type: "text",
+						text: [
+							params.message,
+							"",
+							"Open WhatsApp → Linked Devices and scan:",
+							"",
+							`![whatsapp-qr](${params.qrDataUrl})`
+						].join("\n")
+					}],
+					details: {
+						connected: params.connected ?? false,
+						qr: true
+					}
+				};
+			};
+			const action = args?.action ?? "start";
+			const accountId = readLoginStringPreservingWhitespace(args.accountId);
+			const timeoutMs = readPositiveIntegerParam(args, "timeoutMs");
+			if (action === "wait") {
+				const result = await waitForWebLogin({
+					accountId,
+					timeoutMs,
+					currentQrDataUrl: readLoginStringPreservingWhitespace(args.currentQrDataUrl)
+				});
+				if (result.qrDataUrl) return renderQrReply({
+					message: result.message,
+					qrDataUrl: result.qrDataUrl,
+					connected: result.connected
+				});
+				return {
+					content: [{
+						type: "text",
+						text: result.message
+					}],
+					details: { connected: result.connected }
+				};
+			}
+			const result = await startWebLoginWithQr({
+				accountId,
+				timeoutMs,
+				force: typeof args.force === "boolean" ? args.force : false
+			});
+			if (!result.qrDataUrl) return {
+				content: [{
+					type: "text",
+					text: result.message
+				}],
+				details: { qr: false }
+			};
+			return renderQrReply({
+				message: result.message,
+				qrDataUrl: result.qrDataUrl,
+				connected: result.connected
+			});
+		}
+	};
+}
+//#endregion
+export { createWhatsAppLoginTool as t };

package/dist/api.js

@@ -1,108 +1,63 @@
-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-CSqLvCY5.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-BX2fZUyR.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { a as normalizeWhatsAppAllowFromEntries, c as normalizeWhatsAppTarget, i as looksLikeWhatsAppTargetId, r as isWhatsAppUserTarget, s as normalizeWhatsAppMessagingTarget, t as isWhatsAppGroupJid } from "./normalize-target-CugRyONv.js";
 import { t as resolveWhatsAppOutboundTarget } from "./resolve-outbound-target-1GqbT1uX.js";
 import { c as toWhatsappJid, i as markdownToWhatsApp, l as toWhatsappJidWithLid, n as isSelfChatMode, r as jidToE164, s as resolveJidToE164, t as assertWebChannel } from "./targets-runtime-TMk0lGuy.js";
 import { n as resolveUserPath, t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
-import { n as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-DcWBc3Hb.js";
-import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy } from "./shared-UcAwtJaq.js";
+import { n as WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, t as whatsappPlugin } from "./channel-DJVQHz_V.js";
+import { a as resolveWhatsAppGroupRequireMention, o as resolveWhatsAppGroupToolPolicy } from "./shared-Dp9M3ZPX.js";
 import { t as whatsappCommandPolicy } from "./command-policy-BIOSHySD.js";
-import { t as whatsappSetupPlugin } from "./channel.setup-C_1u6HN6.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-Cmvd967u.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { a as waitForWaConnection, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter } from "./socket-close-DridEuzz.js";
+import { a as waitForWaConnection, o as DEFAULT_WHATSAPP_SOCKET_TIMING, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter } from "./socket-close-09FojDO2.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-DalGrfGN.js";
-import { n as testing } from "./access-control-pZcxTmd5.js";
-import { d as normalizeMessageContent, f as describeReplyContext, g as extractLocationData, m as extractContextInfo, t as createWebSendApi, x as resolveInboundMediaMimetype, y as extractText } from "./send-api-BY_AkSiB.js";
+import { n as listWhatsAppDirectoryGroupsFromConfig, r as listWhatsAppDirectoryPeersFromConfig } from "./directory-config-Pc4f07wB.js";
+import { c as extractContextInfo, g as resolveInboundMediaMimetype, m as findMessageSection, o as describeReplyContext, p as extractText, t as createWebSendApi, u as extractLocationData } from "./send-api-DimZST3E.js";
+import { asBoolean, isRecord, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatLocationText } from "openclaw/plugin-sdk/channel-inbound";
 //#region extensions/whatsapp/src/qa-driver.runtime.ts
-function isRecord(value) {
-	return Boolean(value && typeof value === "object");
-}
-function readString(value) {
-	return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-function readBoolean(value) {
-	return typeof value === "boolean" ? value : void 0;
-}
-function findMessageSection(message, sectionNames) {
-	if (!isRecord(message)) return;
-	const queue = [{
-		depth: 0,
-		value: message
-	}];
-	const seen = /* @__PURE__ */ new Set();
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (!current || seen.has(current.value)) continue;
-		seen.add(current.value);
-		for (const sectionName of sectionNames) {
-			const section = current.value[sectionName];
-			if (isRecord(section)) return section;
-		}
-		if (current.depth >= 4) continue;
-		for (const wrapperName of [
-			"botInvokeMessage",
-			"documentWithCaptionMessage",
-			"ephemeralMessage",
-			"groupMentionedMessage",
-			"viewOnceMessage",
-			"viewOnceMessageV2",
-			"viewOnceMessageV2Extension"
-		]) {
-			const wrapper = current.value[wrapperName];
-			if (isRecord(wrapper) && isRecord(wrapper.message)) queue.push({
-				depth: current.depth + 1,
-				value: wrapper.message
-			});
-		}
-	}
-}
 function readReaction(message) {
-	const reaction = findMessageSection(message, ["reactionMessage"]);
+	const reaction = findMessageSection(message ?? void 0, ["reactionMessage"])?.value;
 	if (!reaction) return;
-	const emoji = readString(reaction.text) ?? "";
+	const emoji = normalizeOptionalString(reaction.text) ?? "";
 	const key = isRecord(reaction.key) ? reaction.key : void 0;
 	return {
 		emoji,
-		fromMe: readBoolean(key?.fromMe),
-		messageId: readString(key?.id),
-		participant: readString(key?.participant)
+		fromMe: asBoolean(key?.fromMe),
+		messageId: normalizeOptionalString(key?.id),
+		participant: normalizeOptionalString(key?.participant)
 	};
 }
 function readPoll(message) {
-	const poll = findMessageSection(message, [
+	const poll = findMessageSection(message ?? void 0, [
 		"pollCreationMessage",
 		"pollCreationMessageV2",
-		"pollCreationMessageV3"
-	]);
+		"pollCreationMessageV3",
+		"pollCreationMessageV5"
+	])?.value;
 	if (!poll) return;
 	return {
-		options: (Array.isArray(poll.options) ? poll.options : []).map((option) => isRecord(option) ? readString(option.optionName) : void 0).filter((option) => Boolean(option)),
-		question: readString(poll.name)
+		options: (Array.isArray(poll.options) ? poll.options : []).map((option) => isRecord(option) ? normalizeOptionalString(option.optionName) : void 0).filter((option) => Boolean(option)),
+		question: normalizeOptionalString(poll.name)
 	};
 }
 function readMedia(message) {
-	const normalizedMessage = isRecord(message) ? normalizeMessageContent(message) : void 0;
-	for (const sectionName of [
+	const media = findMessageSection(message ?? void 0, [
 		"imageMessage",
 		"videoMessage",
+		"ptvMessage",
 		"audioMessage",
 		"documentMessage",
 		"stickerMessage"
-	]) {
-		const section = findMessageSection(normalizedMessage ?? message, [sectionName]);
-		if (!section) continue;
-		const mediaMessage = { [sectionName]: section };
-		return {
-			fileName: readString(section.fileName),
-			mediaType: resolveInboundMediaMimetype(mediaMessage)
-		};
-	}
+	]);
+	return media ? {
+		fileName: normalizeOptionalString(media.value.fileName),
+		mediaType: resolveInboundMediaMimetype({ [media.name]: media.value })
+	} : void 0;
 }
 function readQuotedMessage(message) {
 	const contextInfo = extractContextInfo(message.message ?? void 0);
-	const replyContext = describeReplyContext(message.message);
+	const replyContext = describeReplyContext(message.message ?? void 0);
 	if (!contextInfo && !replyContext) return;
 	if (!contextInfo?.stanzaId && !contextInfo?.participant && !replyContext?.body) return;
 	return {
@@ -114,7 +69,7 @@ function readQuotedMessage(message) {
 function normalizeObservedMessage(message, authDir) {
 	if (message.key.fromMe) return null;
 	const extractedText = extractText(message.message ?? void 0);
-	const location = extractLocationData(message.message);
+	const location = extractLocationData(message.message ?? void 0);
 	const text = [extractedText, location ? formatLocationText(location) : void 0].filter(Boolean).join("\n").trim() || void 0;
 	const reaction = readReaction(message.message);
 	const poll = readPoll(message.message);
@@ -141,15 +96,6 @@ function normalizeObservedMessage(message, authDir) {
 		text: text ?? ""
 	};
 }
-function closeSocket(sock) {
-	const maybeEnd = sock.end;
-	if (typeof maybeEnd === "function") {
-		maybeEnd.call(sock);
-		return;
-	}
-	const maybeClose = sock.ws?.close;
-	if (typeof maybeClose === "function") maybeClose.call(sock.ws);
-}
 function createConnectionClosedError(update) {
 	const reason = update.lastDisconnect?.error;
 	const status = getStatusCode(reason);
@@ -160,32 +106,26 @@ function createConnectionClosedError(update) {
 async function startWhatsAppQaDriverSession(params) {
 	const sock = await createWaSocket(false, false, { authDir: params.authDir });
 	const observedMessages = [];
-	const pendingNotificationsWaiters = [];
-	const waiters = [];
+	const waiters = /* @__PURE__ */ new Set();
+	let pendingNotificationsWaiter;
 	let closed = false;
 	let closedError;
 	let receivedPendingNotifications = false;
 	const removeWaiter = (waiter) => {
-		const index = waiters.indexOf(waiter);
-		if (index >= 0) waiters.splice(index, 1);
+		waiters.delete(waiter);
 		clearTimeout(waiter.timeout);
 	};
-	const removePendingNotificationsWaiter = (waiter) => {
-		const index = pendingNotificationsWaiters.indexOf(waiter);
-		if (index >= 0) pendingNotificationsWaiters.splice(index, 1);
+	const settlePendingNotifications = (error) => {
+		const waiter = pendingNotificationsWaiter;
+		if (!waiter) return;
+		pendingNotificationsWaiter = void 0;
 		clearTimeout(waiter.timeout);
-	};
-	const markPendingNotificationsReceived = () => {
-		if (receivedPendingNotifications) return;
-		receivedPendingNotifications = true;
-		for (const waiter of pendingNotificationsWaiters.slice()) {
-			removePendingNotificationsWaiter(waiter);
-			waiter.resolve();
-		}
+		if (error) waiter.reject(error);
+		else waiter.resolve();
 	};
 	const observe = (message) => {
 		observedMessages.push(message);
-		for (const waiter of waiters.slice()) {
+		for (const waiter of waiters) {
 			if (!waiter.predicate(message)) continue;
 			removeWaiter(waiter);
 			waiter.resolve(message);
@@ -198,28 +138,27 @@ async function startWhatsAppQaDriverSession(params) {
 		}
 	};
 	const onConnectionUpdate = (event) => {
-		if (event.receivedPendingNotifications === true) markPendingNotificationsReceived();
+		if (event.receivedPendingNotifications === true) {
+			receivedPendingNotifications = true;
+			settlePendingNotifications();
+		}
 		if (event.connection === "close") closeSessionResources(createConnectionClosedError(event));
 	};
 	const removeMessageListener = () => {
-		const evWithOff = sock.ev;
-		evWithOff.off?.("messages.upsert", onMessagesUpsert);
-		evWithOff.off?.("connection.update", onConnectionUpdate);
+		sock.ev.off("messages.upsert", onMessagesUpsert);
+		sock.ev.off("connection.update", onConnectionUpdate);
 	};
 	const closeSessionResources = (waiterError) => {
 		if (closed) return;
 		closed = true;
 		closedError = waiterError;
-		for (const waiter of pendingNotificationsWaiters.slice()) {
-			removePendingNotificationsWaiter(waiter);
-			if (waiterError) waiter.reject(waiterError);
-		}
-		for (const waiter of waiters.slice()) {
+		settlePendingNotifications(waiterError);
+		for (const waiter of waiters) {
 			removeWaiter(waiter);
 			if (waiterError) waiter.reject(waiterError);
 		}
 		removeMessageListener();
-		closeSocket(sock);
+		sock.end(void 0);
 	};
 	sock.ev.on("messages.upsert", onMessagesUpsert);
 	sock.ev.on("connection.update", onConnectionUpdate);
@@ -235,15 +174,14 @@ async function startWhatsAppQaDriverSession(params) {
 				return;
 			}
 			const timeoutMs = params.connectionTimeoutMs ?? 45e3;
-			const waiter = {
+			pendingNotificationsWaiter = {
 				resolve,
 				reject,
 				timeout: setTimeout(() => {
-					removePendingNotificationsWaiter(waiter);
+					pendingNotificationsWaiter = void 0;
 					reject(/* @__PURE__ */ new Error(`timed out after ${timeoutMs}ms waiting for WhatsApp QA driver pending notifications`));
 				}, timeoutMs)
 			};
-			pendingNotificationsWaiters.push(waiter);
 		});
 	} catch (error) {
 		closeSessionResources(error instanceof Error ? error : /* @__PURE__ */ new Error("failed starting WhatsApp QA driver session"));
@@ -261,26 +199,26 @@ async function startWhatsAppQaDriverSession(params) {
 		getObservedMessages() {
 			return [...observedMessages];
 		},
-		async sendContact(to, contact) {
-			return { messageId: (await sendApi.sendContact(to, contact)).messageId };
+		sendContact(to, contact) {
+			return toMessageIdResult(sendApi.sendContact(to, contact));
 		},
-		async sendLocation(to, location) {
-			return { messageId: (await sendApi.sendLocation(to, location)).messageId };
+		sendLocation(to, location) {
+			return toMessageIdResult(sendApi.sendLocation(to, location));
 		},
-		async sendMedia(to, text, mediaBuffer, mediaType, options) {
-			return { messageId: (await sendApi.sendMessage(to, text, mediaBuffer, mediaType, options)).messageId };
+		sendMedia(to, text, mediaBuffer, mediaType, options) {
+			return toMessageIdResult(sendApi.sendMessage(to, text, mediaBuffer, mediaType, options));
 		},
-		async sendPoll(to, poll) {
-			return { messageId: (await sendApi.sendPoll(to, poll)).messageId };
+		sendPoll(to, poll) {
+			return toMessageIdResult(sendApi.sendPoll(to, poll));
 		},
-		async sendReaction(chatJid, messageId, emoji, options) {
-			return { messageId: (await sendApi.sendReaction(chatJid, messageId, emoji, options.fromMe, options.participant)).messageId };
+		sendReaction(chatJid, messageId, emoji, options) {
+			return toMessageIdResult(sendApi.sendReaction(chatJid, messageId, emoji, options.fromMe, options.participant));
 		},
-		async sendSticker(to, stickerBuffer, options) {
-			return { messageId: (await sendApi.sendSticker(to, stickerBuffer, options)).messageId };
+		sendSticker(to, stickerBuffer, options) {
+			return toMessageIdResult(sendApi.sendSticker(to, stickerBuffer, options));
 		},
-		async sendText(to, text, options) {
-			return { messageId: (await sendApi.sendMessage(to, text, void 0, void 0, options)).messageId };
+		sendText(to, text, options) {
+			return toMessageIdResult(sendApi.sendMessage(to, text, void 0, void 0, options));
 		},
 		async waitForMessage(paramsLocal) {
 			const predicate = (message) => (!paramsLocal.observedAfter || new Date(message.observedAt).getTime() >= paramsLocal.observedAfter.getTime()) && paramsLocal.match(message);
@@ -297,10 +235,14 @@ async function startWhatsAppQaDriverSession(params) {
 						reject(/* @__PURE__ */ new Error("timed out waiting for WhatsApp QA driver message"));
 					}, paramsLocal.timeoutMs)
 				};
-				waiters.push(waiter);
+				waiters.add(waiter);
 			});
 		}
 	};
 }
+async function toMessageIdResult(pending) {
+	const { messageId } = await pending;
+	return { messageId };
+}
 //#endregion
-export { DEFAULT_WEB_MEDIA_BYTES, DEFAULT_WHATSAPP_MEDIA_MAX_MB, WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, assertWebChannel, hasAnyWhatsAppAuth, isSelfChatMode, isWhatsAppGroupJid, isWhatsAppUserTarget, jidToE164, listEnabledWhatsAppAccounts, listAccountIds as listWhatsAppAccountIds, listWhatsAppAuthDirs, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, looksLikeWhatsAppTargetId, markdownToWhatsApp, normalizeE164, normalizeWhatsAppAllowFromEntries, normalizeWhatsAppMessagingTarget, normalizeWhatsAppTarget, resolveDefaultWhatsAppAccountId, resolveJidToE164, resolveUserPath, resolveWhatsAppAccount, resolveWhatsAppAuthDir, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, resolveWhatsAppMediaMaxBytes, resolveWhatsAppOutboundTarget, startWhatsAppQaDriverSession, toWhatsappJid, toWhatsappJidWithLid, testing as whatsappAccessControlTesting, whatsappCommandPolicy, whatsappPlugin, whatsappSetupPlugin };
+export { DEFAULT_WEB_MEDIA_BYTES, DEFAULT_WHATSAPP_MEDIA_MAX_MB, WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS, assertWebChannel, hasAnyWhatsAppAuth, isSelfChatMode, isWhatsAppGroupJid, isWhatsAppUserTarget, jidToE164, listEnabledWhatsAppAccounts, listAccountIds as listWhatsAppAccountIds, listWhatsAppAuthDirs, listWhatsAppDirectoryGroupsFromConfig, listWhatsAppDirectoryPeersFromConfig, looksLikeWhatsAppTargetId, markdownToWhatsApp, normalizeE164, normalizeWhatsAppAllowFromEntries, normalizeWhatsAppMessagingTarget, normalizeWhatsAppTarget, resolveDefaultWhatsAppAccountId, resolveJidToE164, resolveUserPath, resolveWhatsAppAccount, resolveWhatsAppAuthDir, resolveWhatsAppGroupRequireMention, resolveWhatsAppGroupToolPolicy, resolveWhatsAppMediaMaxBytes, resolveWhatsAppOutboundTarget, startWhatsAppQaDriverSession, toWhatsappJid, toWhatsappJidWithLid, whatsappCommandPolicy, whatsappPlugin, whatsappSetupPlugin };