@openclaw/whatsapp 2026.7.1-beta.2 → 2026.7.1-beta.4

package/dist/runtime-api.js

@@ -1,16 +1,16 @@
 import { o as resolveWebCredsBackupPath, r as hasWebCredsSync, s as resolveWebCredsPath } from "./creds-files-B1kSWtBg.js";
-import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-hqza0J8B.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-i8Xk5mBQ.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-DPahAqxV.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-C5CpFcBG.js";
 import { r as setWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { n as getStatusCode, t as formatError } from "./session-errors-CbsoQqoy.js";
+import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
 import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-BX7eHgDm.js";
-import { C as waitForCredsSaveQueue, T as writeCredsJsonAtomically, _ as readWebSelfIdentity, a as formatWhatsAppWebAuthStatusState, b as restoreCredsFromBackupIfNeeded, c as logoutWeb, d as readWebAuthExistsBestEffort, f as readWebAuthExistsForDecision, g as readWebSelfId, h as readWebAuthState, l as pickWebChannel, m as readWebAuthSnapshotBestEffort, n as WHATSAPP_AUTH_UNSTABLE_CODE, o as getWebAuthAgeMs, p as readWebAuthSnapshot, r as WhatsAppAuthUnstableError, s as logWebSelfId, t as WA_WEB_AUTH_DIR, u as readCredsJsonRaw, v as readWebSelfIdentityForDecision, w as waitForCredsSaveQueueWithTimeout, x as webAuthExists, y as resolveDefaultWebAuthDir } from "./auth-store-ECx4h57q.js";
+import { C as waitForCredsSaveQueue, T as writeCredsJsonAtomically, _ as readWebSelfIdentity, a as formatWhatsAppWebAuthStatusState, b as restoreCredsFromBackupIfNeeded, c as logoutWeb, d as readWebAuthExistsBestEffort, f as readWebAuthExistsForDecision, g as readWebSelfId, h as readWebAuthState, l as pickWebChannel, m as readWebAuthSnapshotBestEffort, n as WHATSAPP_AUTH_UNSTABLE_CODE, o as getWebAuthAgeMs, p as readWebAuthSnapshot, r as WhatsAppAuthUnstableError, s as logWebSelfId, t as WA_WEB_AUTH_DIR, u as readCredsJsonRaw, v as readWebSelfIdentityForDecision, w as waitForCredsSaveQueueWithTimeout, x as webAuthExists, y as resolveDefaultWebAuthDir } from "./auth-store-Db-wfApd.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { _ as extractLocationData, b as extractText, m as extractContactContext, v as extractMediaPlaceholder } from "./send-api-DndiBJhN.js";
-import { n as newConnectionId, r as waitForWaConnection, t as createWaSocket } from "./session-WU4SVP8f.js";
-import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-CFwkn3ho.js";
-import { a as loadWebMediaRaw, c as monitorWebInbox, i as loadWebMedia, l as resetWebInboundDedupe, n as LocalMediaAccessError, o as optimizeImageToJpeg, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel } from "./monitor-BqkJ4MpT.js";
-import { t as loginWeb } from "./login-8lHwLmXj.js";
+import { _ as extractLocationData, b as extractText, m as extractContactContext, v as extractMediaPlaceholder } from "./send-api-DLlXl8CH.js";
+import { n as newConnectionId, r as waitForWaConnection, t as createWaSocket } from "./session-DriaHt7V.js";
+import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-B4SDebQ6.js";
+import { a as loadWebMediaRaw, c as monitorWebInbox, i as loadWebMedia, l as resetWebInboundDedupe, n as LocalMediaAccessError, o as optimizeImageToJpeg, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel } from "./monitor-DD8bXohk.js";
+import { t as loginWeb } from "./login-C48y0jlx.js";
 import { HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN, stripHeartbeatToken } from "openclaw/plugin-sdk/reply-runtime";
 export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, LocalMediaAccessError, SILENT_REPLY_TOKEN, WA_WEB_AUTH_DIR, WHATSAPP_AUTH_UNSTABLE_CODE, WhatsAppAuthUnstableError, createWaSocket, createWhatsAppLoginTool, extractContactContext, extractLocationData, extractMediaPlaceholder, extractText, formatError, formatWhatsAppWebAuthStatusState, getActiveWebListener, getDefaultLocalRoots, getStatusCode, getWebAuthAgeMs, handleWhatsAppAction, hasWebCredsSync, loadWebMedia, loadWebMediaRaw, logWebSelfId, loginWeb, logoutWeb, monitorWebChannel, monitorWebInbox, newConnectionId, optimizeImageToJpeg, optimizeImageToPng, pickWebChannel, readCredsJsonRaw, readWebAuthExistsBestEffort, readWebAuthExistsForDecision, readWebAuthSnapshot, readWebAuthSnapshotBestEffort, readWebAuthState, readWebSelfId, readWebSelfIdentity, readWebSelfIdentityForDecision, resetWebInboundDedupe, resolveDefaultWebAuthDir, resolveWebAccountId, resolveWebCredsBackupPath, resolveWebCredsPath, restoreCredsFromBackupIfNeeded, sendMessageWhatsApp, sendPollWhatsApp, sendReactionWhatsApp, sendTypingWhatsApp, setWhatsAppRuntime, startWebLoginWithQr, stripHeartbeatToken, waitForCredsSaveQueue, waitForCredsSaveQueueWithTimeout, waitForWaConnection, waitForWebLogin, webAuthExists, whatsAppActionRuntime, writeCredsJsonAtomically };

package/dist/{send-i8Xk5mBQ.js → send-C5CpFcBG.js}

@@ -1,12 +1,14 @@
 import { t as resolveMergedWhatsAppAccountConfig } from "./account-config-6PTOSfaI.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-DgViSyJx.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-4YgwroRU.js";
 import { c as normalizeWhatsAppTarget, n as isWhatsAppNewsletterJid } from "./normalize-target-bVWjgftN.js";
 import "./normalize-Bxwqo-bW.js";
 import { t as getOptionalWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
-import { r as getRegisteredWhatsAppConnectionController, t as formatError } from "./session-errors-CbsoQqoy.js";
-import { r as isWhatsAppSocketOperationTimeoutError } from "./socket-timing-DvMNkIge.js";
-import { a as sanitizeAssistantVisibleTextWithProfile, d as markdownToWhatsApp, i as sanitizeAssistantVisibleText, m as toWhatsappJid, o as sleep, s as stripToolCallXmlTags } from "./text-runtime-C88QkuU9.js";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.js";
+import { t as formatError } from "./session-errors-BAj9D2La.js";
+import { r as isWhatsAppSocketOperationTimeoutError } from "./socket-timing-DhbVFjah.js";
+import { i as markdownToWhatsApp, s as toWhatsappJid } from "./targets-runtime-C-GiVn6Y.js";
+import { a as sanitizeAssistantVisibleTextWithProfile, i as sanitizeAssistantVisibleText, o as sleep, s as stripToolCallXmlTags } from "./text-runtime-DdX6-mC_.js";
 import path from "node:path";
 import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
@@ -83,7 +85,7 @@ const whatsappApprovalAuth = { authorizeActorAction({ cfg, accountId, senderId,
 const PERSISTENT_NAMESPACE = "whatsapp.approval-reactions";
 const PERSISTENT_MAX_ENTRIES = 1e3;
 const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
-const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-e1hAVRRy.js"));
+const resolverRuntimeLoader = createLazyRuntimeModule(() => import("./approval-resolver-DF-lu8k5.js"));
 const whatsappApprovalReactionTargets = createApprovalReactionTargetStore({
 	namespace: PERSISTENT_NAMESPACE,
 	maxEntries: PERSISTENT_MAX_ENTRIES,
@@ -625,7 +627,10 @@ async function sendMessageWhatsApp(to, body, options) {
 			jid: redactedJid,
 			hasMedia
 		}, "sending message");
-		if (!isWhatsAppNewsletterJid(jid)) await active.sendComposingTo(to);
+		if (!isWhatsAppNewsletterJid(jid)) {
+			await active.assertSendReady?.(to);
+			await active.sendComposingTo(to);
+		}
 		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
 		const sendOptions = options.gifPlayback || forceDocumentDelivery || accountId || documentFileName || options.quotedMessageKey ? {
 			...options.gifPlayback ? { gifPlayback: true } : {},
@@ -635,10 +640,19 @@ async function sendMessageWhatsApp(to, body, options) {
 			accountId
 		} : void 0;
 		const result = sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType);
-		if (visibleTextAfterVoice) if (sendOptions) await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0, sendOptions);
-		else await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0);
 		const messageId = result?.messageId ?? "unknown";
 		const sentRemoteJid = resolveActualSentRemoteJid(result, jid);
+		if (visibleTextAfterVoice) {
+			await options.onDeliveryResult?.({
+				messageId,
+				toJid: sentRemoteJid
+			});
+			const captionResult = sendOptions ? await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0, sendOptions) : await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0);
+			await options.onDeliveryResult?.({
+				messageId: captionResult?.messageId ?? "unknown",
+				toJid: resolveActualSentRemoteJid(captionResult, jid)
+			});
+		}
 		if (messageId && messageId !== "unknown" && text) registerWhatsAppApprovalReactionTargetForOutboundMessage({
 			accountId: resolvedAccountId,
 			remoteJid: sentRemoteJid,
@@ -669,7 +683,10 @@ async function sendTypingWhatsApp(to, options) {
 		cfg: requireRuntimeConfig(options.cfg, "WhatsApp typing send"),
 		accountId: options.accountId
 	});
-	if (!isWhatsAppNewsletterJid(toWhatsappJid(to))) await active.sendComposingTo(to);
+	if (!isWhatsAppNewsletterJid(toWhatsappJid(to))) {
+		await active.assertSendReady?.(to);
+		await active.sendComposingTo(to);
+	}
 }
 async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
 	const correlationId = generateSecureUuid();
@@ -732,6 +749,7 @@ async function sendPollWhatsApp(to, poll, options) {
 			optionCount: normalized.options.length,
 			maxSelections: normalized.maxSelections
 		}, "sending poll");
+		if (!isWhatsAppNewsletterJid(jid)) await active.assertSendReady?.(to);
 		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
 		const durationMs = Date.now() - startedAt;
 		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);

package/dist/{send-api-DndiBJhN.js → send-api-DLlXl8CH.js}

@@ -1,9 +1,10 @@
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-bVWjgftN.js";
-import { u as resolveWhatsAppDocumentFileName } from "./send-i8Xk5mBQ.js";
+import { u as resolveWhatsAppDocumentFileName } from "./send-C5CpFcBG.js";
 import "./normalize-Bxwqo-bW.js";
-import { h as toWhatsappJidWithLid, m as toWhatsappJid, u as jidToE164 } from "./text-runtime-C88QkuU9.js";
-import { t as buildQuotedMessageOptions } from "./quoted-message-CpA_ujXK.js";
-import { c as resolveComparableIdentity } from "./identity-CmsTmkKR.js";
+import { c as toWhatsappJidWithLid, r as jidToE164, s as toWhatsappJid } from "./targets-runtime-C-GiVn6Y.js";
+import "./text-runtime-DdX6-mC_.js";
+import { i as buildQuotedMessageOptions } from "./group-session-key-BhC1RQOE.js";
+import { c as resolveComparableIdentity } from "./identity-Dqft3mFA.js";
 import { normalizeLowercaseStringOrEmpty, normalizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds } from "openclaw/plugin-sdk/channel-outbound";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -13,7 +14,7 @@ import { DisconnectReason, downloadMediaMessage, extractMessageContent, getConte
 import "openclaw/plugin-sdk/media-store";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
 //#region extensions/whatsapp/src/vcard.ts
-const ALLOWED_VCARD_KEYS = new Set([
+const ALLOWED_VCARD_KEYS = /* @__PURE__ */ new Set([
 	"FN",
 	"N",
 	"TEL"

package/dist/{session-WU4SVP8f.js → session-DriaHt7V.js}

@@ -1,7 +1,7 @@
 import { o as resolveWebCredsBackupPath, s as resolveWebCredsPath, t as assertWebCredsPathRegularFileOrMissing } from "./creds-files-B1kSWtBg.js";
-import { n as getStatusCode } from "./session-errors-CbsoQqoy.js";
-import { t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DvMNkIge.js";
-import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-ECx4h57q.js";
+import { n as getStatusCode } from "./session-errors-BAj9D2La.js";
+import { t as DEFAULT_WHATSAPP_SOCKET_TIMING } from "./socket-timing-DhbVFjah.js";
+import { E as writeWebCredsRawAtomically, S as enqueueCredsSave, T as writeCredsJsonAtomically, b as restoreCredsFromBackupIfNeeded, u as readCredsJsonRaw, w as waitForCredsSaveQueueWithTimeout, y as resolveDefaultWebAuthDir } from "./auth-store-Db-wfApd.js";
 import { i as makeWASocket, n as fetchLatestBaileysVersion, o as useMultiFileAuthState, r as makeCacheableSignalKeyStore } from "./session.runtime-CyooSQvj.js";
 import { VERSION, formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { danger, getChildLogger, success, toPinoLikeLogger } from "openclaw/plugin-sdk/runtime-env";

package/dist/{session-errors-CbsoQqoy.js → session-errors-BAj9D2La.js}

@@ -1,24 +1,3 @@
-//#region extensions/whatsapp/src/connection-controller-registry.ts
-const CONNECTION_REGISTRY_KEY = Symbol.for("openclaw.whatsapp.connectionControllerRegistry");
-function getConnectionRegistryState() {
-	const globalState = globalThis;
-	const existing = globalState[CONNECTION_REGISTRY_KEY];
-	if (existing) return existing;
-	const created = { controllers: /* @__PURE__ */ new Map() };
-	globalState[CONNECTION_REGISTRY_KEY] = created;
-	return created;
-}
-function getRegisteredWhatsAppConnectionController(accountId) {
-	return getConnectionRegistryState().controllers.get(accountId) ?? null;
-}
-function registerWhatsAppConnectionController(accountId, controller) {
-	getConnectionRegistryState().controllers.set(accountId, controller);
-}
-function unregisterWhatsAppConnectionController(accountId, controller) {
-	const controllers = getConnectionRegistryState().controllers;
-	if (controllers.get(accountId) === controller) controllers.delete(accountId);
-}
-//#endregion
 //#region extensions/whatsapp/src/session-errors.ts
 function safeStringify(value, limit = 800) {
 	try {
@@ -81,4 +60,4 @@ function formatError(err) {
 	return safeStringify(err);
 }
 //#endregion
-export { unregisterWhatsAppConnectionController as a, registerWhatsAppConnectionController as i, getStatusCode as n, getRegisteredWhatsAppConnectionController as r, formatError as t };
+export { getStatusCode as n, formatError as t };

package/dist/{setup-core-KjSBbWX4.js → setup-core-DH-DFPLY.js}

@@ -1,7 +1,7 @@
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-DgViSyJx.js";
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-4YgwroRU.js";
 import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-bVWjgftN.js";
-import { t as WhatsAppChannelConfigSchema } from "./config-schema-CROZuhT-.js";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-mBX2nmn1.js";
 import { n as whatsappDoctor } from "./doctor-By3SB4lm.js";
 import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
@@ -99,10 +99,10 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
 async function loadWhatsAppChannelRuntime() {
-	return await import("./channel.runtime-B4ThooGF.js");
+	return await import("./channel.runtime-CAssfx9p.js");
 }
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-IOdkbWsQ.js");
+	return await import("./setup-surface-DlWb0Z09.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({

package/dist/{setup-finalize-WedNP30s.js → setup-finalize-c8dl34sO.js}

@@ -1,8 +1,8 @@
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
 import { r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
-import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-DgViSyJx.js";
+import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-4YgwroRU.js";
 import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-bVWjgftN.js";
-import { t as whatsappSetupAdapter } from "./setup-core-KjSBbWX4.js";
+import { t as whatsappSetupAdapter } from "./setup-core-DH-DFPLY.js";
 import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
 //#region extensions/whatsapp/src/setup-finalize.ts
@@ -280,7 +280,7 @@ async function finalizeWhatsAppSetup(params) {
 		message: linked ? t("wizard.whatsapp.relinkPrompt") : t("wizard.whatsapp.linkNowPrompt"),
 		initialValue: !linked
 	})) try {
-		const { loginWeb } = await import("./login-8lHwLmXj.js").then((n) => n.n);
+		const { loginWeb } = await import("./login-C48y0jlx.js").then((n) => n.n);
 		await loginWeb(false, void 0, params.runtime, accountId);
 	} catch (error) {
 		params.runtime.error(`WhatsApp login failed: ${String(error)}`);

package/dist/setup-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as whatsappSetupPlugin } from "./channel.setup-C_WEdyJR.js";
+import { t as whatsappSetupPlugin } from "./channel.setup-CURc5rEt.js";
 export { whatsappSetupPlugin };

package/dist/{setup-surface-IOdkbWsQ.js → setup-surface-DlWb0Z09.js}

@@ -1,6 +1,6 @@
 import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
-import { o as resolveWhatsAppAuthDir } from "./accounts-DgViSyJx.js";
-import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-ECx4h57q.js";
+import { o as resolveWhatsAppAuthDir } from "./accounts-4YgwroRU.js";
+import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-Db-wfApd.js";
 import { DEFAULT_ACCOUNT_ID, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 //#region extensions/whatsapp/src/setup-surface.ts
 const t = createSetupTranslator();
@@ -36,7 +36,7 @@ const whatsappSetupWizard = {
 	},
 	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
 	credentials: [],
-	finalize: async (params) => await (await import("./setup-finalize-WedNP30s.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-c8dl34sO.js")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/{socket-timing-DvMNkIge.js → socket-timing-DhbVFjah.js}

@@ -1,5 +1,6 @@
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 //#region extensions/whatsapp/src/socket-timing.ts
+const socketSendMessageQueueTails = /* @__PURE__ */ new WeakMap();
 const DEFAULT_WHATSAPP_SOCKET_TIMING = {
 	keepAliveIntervalMs: 25e3,
 	connectTimeoutMs: 6e4,
@@ -31,6 +32,15 @@ function isWhatsAppSocketOperationTimeoutError(error) {
 function resolveWhatsAppSocketOperationTimeoutMs(timeoutMs) {
 	return resolveTimerTimeoutMs(timeoutMs, DEFAULT_WHATSAPP_SOCKET_TIMING.defaultQueryTimeoutMs);
 }
+async function runSerializedSocketSendMessage(sock, run) {
+	const result = (socketSendMessageQueueTails.get(sock) ?? Promise.resolve()).then(run);
+	const tail = result.then(() => void 0, () => void 0);
+	socketSendMessageQueueTails.set(sock, tail);
+	tail.then(() => {
+		if (socketSendMessageQueueTails.get(sock) === tail) socketSendMessageQueueTails.delete(sock);
+	});
+	return await result;
+}
 async function withWhatsAppSocketOperationTimeout(operation, promise, timeoutMs, onTimeout) {
 	const resolvedTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(timeoutMs);
 	let timeout = null;
@@ -50,11 +60,13 @@ function createWhatsAppSocketOperationTimeoutAdapter(sock, timeoutMs, hooks) {
 	const operationTimeoutMs = resolveWhatsAppSocketOperationTimeoutMs(timeoutMs);
 	return {
 		sendMessage: (jid, content, options) => {
-			const send = options ? sock.sendMessage(jid, content, options) : sock.sendMessage(jid, content);
-			return withWhatsAppSocketOperationTimeout("sendMessage", send, operationTimeoutMs, hooks?.onSendMessageTimeout ? () => hooks.onSendMessageTimeout?.({
-				jid,
-				promise: send
-			}) : void 0);
+			return runSerializedSocketSendMessage(sock, () => {
+				const send = options ? sock.sendMessage(jid, content, options) : sock.sendMessage(jid, content);
+				return withWhatsAppSocketOperationTimeout("sendMessage", send, operationTimeoutMs, hooks?.onSendMessageTimeout ? () => hooks.onSendMessageTimeout?.({
+					jid,
+					promise: send
+				}) : void 0);
+			});
 		},
 		sendPresenceUpdate: (presence, jid) => {
 			return withWhatsAppSocketOperationTimeout("sendPresenceUpdate", jid === void 0 ? sock.sendPresenceUpdate(presence) : sock.sendPresenceUpdate(presence, jid), operationTimeoutMs);

package/dist/{text-runtime-C88QkuU9.js → targets-runtime-C-GiVn6Y.js}

@@ -2,8 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { normalizeE164 } from "openclaw/plugin-sdk/account-resolution";
 import { logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { convertMarkdownTables, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
-import { CONFIG_DIR, escapeRegExp, normalizeE164 as normalizeE164$1, resolveUserPath as resolveUserPath$1, resolveUserPath as resolveUserPath$2, sleep } from "openclaw/plugin-sdk/text-utility-runtime";
+import { CONFIG_DIR, escapeRegExp, resolveUserPath as resolveUserPath$1 } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/whatsapp/src/targets-runtime.ts
 const WHATSAPP_FENCE_PLACEHOLDER = "\0FENCE";
 const WHATSAPP_INLINE_CODE_PLACEHOLDER = "\0CODE";
@@ -186,4 +185,4 @@ function markdownToWhatsApp(text) {
 	return result;
 }
 //#endregion
-export { sanitizeAssistantVisibleTextWithProfile as a, assertWebChannel as c, markdownToWhatsApp as d, resolveEquivalentWhatsAppDirectChatJids as f, toWhatsappJidWithLid as h, sanitizeAssistantVisibleText as i, isSelfChatMode as l, toWhatsappJid as m, normalizeE164$1 as n, sleep as o, resolveJidToE164 as p, resolveUserPath$2 as r, stripToolCallXmlTags as s, convertMarkdownTables as t, jidToE164 as u };
+export { resolveEquivalentWhatsAppDirectChatJids as a, toWhatsappJidWithLid as c, markdownToWhatsApp as i, isSelfChatMode as n, resolveJidToE164 as o, jidToE164 as r, toWhatsappJid as s, assertWebChannel as t };

package/dist/text-runtime-DdX6-mC_.js

@@ -0,0 +1,4 @@
+import "./targets-runtime-C-GiVn6Y.js";
+import { convertMarkdownTables, sanitizeAssistantVisibleText, sanitizeAssistantVisibleTextWithProfile, stripToolCallXmlTags } from "openclaw/plugin-sdk/text-chunking";
+import { normalizeE164, resolveUserPath as resolveUserPath$1, sleep } from "openclaw/plugin-sdk/text-utility-runtime";
+export { sanitizeAssistantVisibleTextWithProfile as a, sanitizeAssistantVisibleText as i, normalizeE164 as n, sleep as o, resolveUserPath$1 as r, stripToolCallXmlTags as s, convertMarkdownTables as t };

package/node_modules/@cacheable/memory/README.md

@@ -29,6 +29,8 @@ Here are some of the main features of `CacheableMemory`:
 * [CacheableMemory Store Hashing](#cacheablememory-store-hashing)
 * [CacheableMemory LRU Feature](#cacheablememory-lru-feature)
 * [CacheableMemory Performance](#cacheablememory-performance)
+* [CacheableMemory Statistics](#cacheablememory-statistics)
+* [CacheableMemory Hooks and Events](#cacheablememory-hooks-and-events)
 * [CacheableMemory Options](#cacheablememory-options)
 * [CacheableMemory - API](#cacheablememory---api)
 * [Keyv Storage Adapter - KeyvCacheableMemory](#keyv-storage-adapter---keyvcacheablememory)
@@ -226,14 +228,138 @@ Our goal with `cacheable` and `CacheableMemory` is to provide a high performance
 
 As you can see from the benchmarks `CacheableMemory` is on par with other caching engines such as `Map`, `Node Cache`, and `bentocache`. We have also tested it against other LRU caching engines such as `quick-lru` and `lru.min` and it performs well against them too.
 
+## Maximum Time to Live (maxTtl)
+
+You can set a `maxTtl` option to enforce an upper bound on any TTL in the cache. When `maxTtl` is set:
+- Any per-entry TTL that exceeds `maxTtl` will be capped to `maxTtl`.
+- Entries with no TTL (that would otherwise live indefinitely) will be capped to `maxTtl`.
+- The default TTL is still respected if it is within the `maxTtl` limit.
+
+This is useful when you want to guarantee that no cache entry lives longer than a certain duration, regardless of what TTL is passed to individual `set()` calls.
+
+```javascript
+import { CacheableMemory } from '@cacheable/memory';
+
+// No entry can live longer than 1 hour
+const cache = new CacheableMemory({ maxTtl: '1h' });
+
+cache.set('key1', 'value1', '2h'); // capped to 1 hour
+cache.set('key2', 'value2');        // also capped to 1 hour (would otherwise be indefinite)
+cache.set('key3', 'value3', '30m'); // 30 minutes is within maxTtl, so it stays as-is
+```
+
+You can also set `maxTtl` after construction:
+
+```javascript
+const cache = new CacheableMemory();
+cache.maxTtl = 5000; // 5 seconds max
+cache.maxTtl = '10m'; // 10 minutes max
+cache.maxTtl = undefined; // disable maxTtl (no upper bound)
+```
+
+## CacheableMemory Statistics
+
+`CacheableMemory` can track runtime statistics using the shared [`Stats`](https://cacheable.org/docs/utils/) implementation from `@cacheable/utils` (the same engine used by `cacheable` and `@cacheable/node-cache`). Statistics are disabled by default. Enable them with the `stats` option or by setting `cache.stats.enabled = true` at any time:
+
+```javascript
+import { CacheableMemory } from '@cacheable/memory';
+
+const cache = new CacheableMemory({ stats: true });
+
+cache.set('key', 'value');
+cache.get('key');     // hit
+cache.get('missing'); // miss
+
+console.log(cache.stats.hits);     // 1
+console.log(cache.stats.misses);   // 1
+console.log(cache.stats.gets);     // 2
+console.log(cache.stats.sets);     // 1
+console.log(cache.stats.count);    // 1
+console.log(cache.stats.hitRate);  // 0.5
+```
+
+The `stats` property exposes the following counters:
+
+* `hits`: The number of reads that found a (non-expired) value.
+* `misses`: The number of reads that did not find a value.
+* `gets`: The number of read operations. Every key read counts as one get, so `getMany(['a', 'b'])` records two gets.
+* `sets`: The number of writes. Every key written counts as one set, including overwrites.
+* `deletes`: The number of keys removed via `delete`/`deleteMany`/`take`, as well as keys evicted by the LRU.
+* `clears`: The number of times `clear()` was called.
+* `count`: The number of keys currently tracked in the cache.
+* `ksize`: The estimated byte size of the keys in the cache.
+* `vsize`: The estimated byte size of the values in the cache.
+* `hitRate` / `missRate`: The ratio of hits / misses to total lookups.
+
+You can get a plain-object snapshot via `cache.stats.toJSON()` and reset all counters with `cache.stats.reset()`.
+
+The `count`, `ksize`, and `vsize` values are kept in sync as entries are added, removed, overwritten, and lazily expired, so they reflect the current contents of the cache. (Expired entries are not counted as `deletes`, since their removal is not user-initiated.) Methods that perform a read internally — such as `has()`, `take()`, and the `wrap()` / `getOrSet()` memoization helpers — flow through `get`/`set`, so they update the statistics as well.
+
+For accurate size counters, enable statistics before populating the cache: `count`/`ksize`/`vsize` only account for entries written while statistics were enabled, and are clamped at `0` so they never go negative if you enable stats after the cache already has data. Changing `storeHashSize` recreates the underlying stores and clears all entries, so the size counters are reset to `0` accordingly.
+
+## CacheableMemory Hooks and Events
+
+`CacheableMemory` extends [`Hookified`](https://github.com/jaredwray/hookified), so you can register handlers that run around cache operations via the `CacheableMemoryHooks` enum and the `onHook()` method:
+
+* `BEFORE_SET`: Called before `set()`. The handler receives `{ key, value, ttl }` and can reassign any of them to change what gets stored.
+* `AFTER_SET`: Called after `set()` with the (possibly modified) `{ key, value, ttl }`.
+* `BEFORE_SET_MANY`: Called before `setMany()` with the array of `CacheableItem`s. Items can be mutated.
+* `AFTER_SET_MANY`: Called after `setMany()` with the array of items.
+* `BEFORE_GET`: Called before `get()` with the `key`.
+* `AFTER_GET`: Called after `get()` with `{ key, result }` (`result` is `undefined` on a cache miss).
+* `BEFORE_GET_MANY`: Called before `getMany()` with the array of `keys`.
+* `AFTER_GET_MANY`: Called after `getMany()` with `{ keys, result }`.
+* `BEFORE_DELETE`: Called before `delete()` with the `key`.
+* `AFTER_DELETE`: Called after `delete()` with the `key`.
+* `BEFORE_DELETE_MANY`: Called before `deleteMany()` with the array of `keys`.
+* `AFTER_DELETE_MANY`: Called after `deleteMany()` with the array of `keys`.
+* `BEFORE_CLEAR`: Called before `clear()`.
+* `AFTER_CLEAR`: Called after `clear()`.
+
+An example of how to use these hooks:
+
+```javascript
+import { CacheableMemory, CacheableMemoryHooks } from '@cacheable/memory';
+
+const cache = new CacheableMemory();
+
+cache.onHook(CacheableMemoryHooks.BEFORE_SET, (item) => {
+  console.log(`before set: ${item.key} ${item.value}`);
+});
+
+cache.onHook(CacheableMemoryHooks.AFTER_GET, (item) => {
+  console.log(`after get: ${item.key} = ${item.result}`);
+});
+```
+
+A `BEFORE_SET` handler can change the `key`, `value`, or `ttl` before the entry is stored. The `ttl` accepts a number (milliseconds), a [shorthand string](#shorthand-for-time-to-live-ttl), or a `SetOptions` object (`{ ttl, expire }`):
+
+```javascript
+cache.onHook(CacheableMemoryHooks.BEFORE_SET, (item) => {
+  item.key = `user:${item.key}`;
+  item.ttl = '1h';
+});
+```
+
+Hooks are dispatched synchronously via `hookSync`, which **skips `async` handler functions entirely** — an `async` handler will not run at all (not merely run un-awaited), so register only synchronous handlers.
+
+> **TypeScript:** the hook payload types are exported so you can annotate your handlers — `CacheableMemoryHookItem`, `CacheableMemoryAfterGetItem`, and `CacheableMemoryAfterGetManyItem`. For example:
+> ```ts
+> cache.onHook(CacheableMemoryHooks.BEFORE_SET, (item: CacheableMemoryHookItem) => {
+>   item.ttl = '1h';
+> });
+> ```
+
 ## CacheableMemory Options
 
 * `ttl`: The time to live for the cache in milliseconds. Default is `undefined` which is means indefinitely.
+* `maxTtl`: The maximum time to live for any cache entry. When set, TTLs exceeding this value are capped. Default is `undefined` (no maximum).
 * `useClones`: If the cache should use clones for the values. Default is `true`.
 * `lruSize`: The size of the LRU cache. Default is `0`, which disables the LRU cache (no LRU eviction is performed). Maximum is `16,777,216 (2^24)`.
 * `checkInterval`: The interval to check for expired keys in milliseconds. Default is `0` which is disabled.
 * `storeHashSize`: The number of `Map` objects to use for the cache. Default is `16`.
 * `storeHashAlgorithm`: The hashing algorithm to use for the cache. Default is `djb2`. Supported: DJB2, FNV1, MURMER, CRC32.
+* `stats`: Whether to track runtime statistics (`hits`, `misses`, `gets`, `sets`, `deletes`, `clears`, `count`, `ksize`, `vsize`). Default is `false`.
 
 ## CacheableMemory - API
 
@@ -251,13 +377,16 @@ As you can see from the benchmarks `CacheableMemory` is on par with other cachin
 * `takeMany([keys])`: Takes multiple values from the cache and deletes them.
 * `wrap(function, WrapSyncOptions)`: Wraps a `sync` function in a cache.
 * `clear()`: Clears the cache.
+* `onHook(hook, handler)`: Registers a handler for a `CacheableMemoryHooks` event. See [CacheableMemory Hooks and Events](#cacheablememory-hooks-and-events).
 * `ttl`: The default time to live for the cache in milliseconds. Default is `undefined` which is disabled.
+* `maxTtl`: The maximum time to live for any cache entry. When set, TTLs exceeding this value are capped. Default is `undefined` (no maximum).
 * `useClones`: If the cache should use clones for the values. Default is `true`.
 * `lruSize`: The size of the LRU cache. Default is `0`, which disables the LRU cache (no LRU eviction is performed). Maximum is `16,777,216 (2^24)`.
 * `size`: The number of keys in the cache.
 * `checkInterval`: The interval to check for expired keys in milliseconds. Default is `0` which is disabled.
 * `storeHashSize`: The number of `Map` objects to use for the cache. Default is `16`.
 * `storeHashAlgorithm`: The hashing algorithm to use for the cache. Default is `djb2`. Supported: DJB2, FNV1, MURMER, CRC32.
+* `stats`: The statistics for this instance which includes `hits`, `misses`, `gets`, `sets`, `deletes`, `clears`, `count`, `vsize`, and `ksize`. Disabled by default; enable via the `stats` option or `cache.stats.enabled = true`.
 * `keys`: Get the keys in the cache. Not able to be set.
 * `items`: Get the items in the cache as `CacheableStoreItem` example `{ key, value, expires? }`.
 * `store`: The hash store for the cache which is an array of `Map` objects.
@@ -332,6 +461,54 @@ If you would like to generate your own key for the wrapped function you can set
 
 We will pass in the `function` that is being wrapped, the `arguments` passed to the function, and the `options` used to wrap the function. You can then use these to generate a custom key for the cache.
 
+# Get Or Set Memoization Function
+
+`CacheableMemory` also has a `getOrSet` method that implements the cache-aside pattern in a single synchronous call. It attempts to retrieve a value from the cache, and if it is not found it calls the provided function to compute the value, stores it, and returns it. This is the synchronous counterpart to the `getOrSet` method on `cacheable` and is backed by `getOrSetSync` from [@cacheable/utils](https://cacheable.org/docs/utils/).
+
+```javascript
+import { CacheableMemory } from '@cacheable/memory';
+
+const cache = new CacheableMemory();
+
+const getUser = () => ({ id: 1, name: 'Alice' });
+
+// First call computes the value and stores it
+const user1 = cache.getOrSet('user:1', getUser, { ttl: '1h' });
+// Second call returns the cached value without calling getUser again
+const user2 = cache.getOrSet('user:1', getUser, { ttl: '1h' });
+
+console.log(user1); // { id: 1, name: 'Alice' }
+console.log(user1 === user2); // true (served from cache)
+```
+
+The third argument accepts the following options:
+
+```typescript
+export type GetOrSetFunctionOptions = {
+	ttl?: number | string;
+	cacheErrors?: boolean;
+	throwErrors?: boolean | 'function' | 'store';
+};
+```
+
+* `ttl`: The time to live for the stored value. If omitted it falls back to the instance default `ttl`. Accepts milliseconds or the [shorthand](#shorthand-for-time-to-live-ttl) format such as `1h`.
+* `cacheErrors`: When `true`, errors thrown by the function are cached so the function is not retried until the entry expires. Default is `false`.
+* `throwErrors`: Controls whether errors are rethrown. `false` (default) emits errors on the `error` event and returns `undefined`; `true` rethrows any error; `'function'` only rethrows errors from the provided function; `'store'` only rethrows errors from reading/writing the cache.
+
+Because `CacheableMemory` is synchronous there is no request coalescing — synchronous code runs to completion without interleaving, so concurrent callers cannot stampede the setter the way they can with the async `getOrSet` on `cacheable`.
+
+You can also pass a function to compute the key:
+
+```javascript
+import { CacheableMemory, GetOrSetSyncKey } from '@cacheable/memory';
+
+const cache = new CacheableMemory();
+
+const generateKey: GetOrSetSyncKey = (options) => `user:${options?.ttl}`;
+
+const value = cache.getOrSet(generateKey, () => Math.random() * 100, { ttl: '1h' });
+```
+
 # How to Contribute
 
 You can contribute by forking the repo and submitting a pull request. Please make sure to add tests and update the documentation. To learn more about how to contribute go to our main README [https://github.com/jaredwray/cacheable](https://github.com/jaredwray/cacheable). This will talk about how to `Open a Pull Request`, `Ask a Question`, or `Post an Issue`.