@openclaw/whatsapp 2026.5.22 → 2026.5.24-beta.1

package/dist/{monitor-ClhD-fQ6.js → monitor-BU1ydkuF.js}

@@ -1,17 +1,19 @@
 import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BPYgj8Fv.js";
 import { t as isWhatsAppGroupJid } from "./normalize-target-bVWjgftN.js";
 import { t as resolveWhatsAppReactionLevel } from "./reaction-level-BqMOEBeq.js";
+import { c as maybeResolveWhatsAppApprovalReaction, r as sendReactionWhatsApp } from "./send-C9jEw6hx.js";
+import { n as getWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import { i as prepareWhatsAppOutboundMedia, o as sendWhatsAppOutboundWithRetry, r as normalizeWhatsAppPayloadTextPreservingIndentation, t as normalizeWhatsAppOutboundPayload } from "./outbound-media-contract-ioTkt8tn.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
 import { d as markdownToWhatsApp, f as resolveJidToE164, l as isSelfChatMode, n as normalizeE164, t as convertMarkdownTables$1, u as jidToE164 } from "./text-runtime-Dk37KYHj.js";
-import { r as sendReactionWhatsApp } from "./send-E_kMiuZP.js";
 import { n as cacheInboundMessageMeta, r as lookupInboundMessageMeta, t as buildQuotedMessageOptions } from "./quoted-message-CveINB35.js";
-import { c as logoutWeb, g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-GTQvJznL.js";
+import { c as logoutWeb, g as readWebSelfId, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision } from "./auth-store-BrKb0mwT.js";
 import { a as getSelfIdentity, c as resolveComparableIdentity, i as getReplyContext, n as getMentionIdentities, o as getSenderIdentity, r as getPrimaryIdentityId, s as identitiesOverlap, t as getComparableIdentityValues } from "./identity-xoLLdqEv.js";
 import { i as resolveWhatsAppInboundPolicy, r as resolveWhatsAppCommandAuthorized, t as checkInboundAccessControl } from "./access-control-p_vcYDW7.js";
-import { a as mayContainWhatsAppOutboundMention, c as extractContactContext, d as extractMediaPlaceholder, f as extractMentionedJids, i as addWhatsAppOutboundMentionsToContent, l as extractContextInfo, m as hasInboundUserContent, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as extractText, r as normalizeWhatsAppSendResult, s as describeReplyContext, t as createWebSendApi, u as extractLocationData } from "./send-api-CXPUXbUL.js";
-import { i as resolveWhatsAppSocketTiming, r as waitForWaConnection, t as createWaSocket } from "./session-CPsgRMMa.js";
-import { c as computeBackoff, d as resolveReconnectPolicy, f as sleepWithAbort, l as newConnectionId, n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController, s as DEFAULT_RECONNECT_POLICY, u as resolveHeartbeatSeconds } from "./connection-controller-9TXWZRhx.js";
+import { a as mayContainWhatsAppOutboundMention, c as extractContactContext, d as extractMediaPlaceholder, f as extractMentionedJids, i as addWhatsAppOutboundMentionsToContent, l as extractContextInfo, m as hasInboundUserContent, n as listWhatsAppSendResultMessageIds, o as resolveWhatsAppOutboundMentions, p as extractText, r as normalizeWhatsAppSendResult, s as describeReplyContext, t as createWebSendApi, u as extractLocationData } from "./send-api-CC-vHBWG.js";
+import { i as resolveWhatsAppSocketTiming, r as waitForWaConnection, t as createWaSocket } from "./session-CDgpDc0l.js";
+import { t as BufferJSON } from "./session.runtime-LZFdq3yb.js";
+import { c as computeBackoff, d as resolveReconnectPolicy, f as sleepWithAbort, l as newConnectionId, n as WHATSAPP_WATCHDOG_TIMEOUT_ERROR, r as WhatsAppConnectionController, s as DEFAULT_RECONNECT_POLICY, u as resolveHeartbeatSeconds } from "./connection-controller-ja6z4F_k.js";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { evaluateSupplementalContextVisibility, filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
@@ -22,17 +24,20 @@ import { resolveMarkdownTableMode as resolveMarkdownTableMode$1 } from "openclaw
 import { createSubsystemLogger, defaultRuntime, formatDurationPrecise, getChildLogger as getChildLogger$1, logVerbose, logVerbose as logVerbose$1, registerUnhandledRejectionHandler, shouldLogVerbose, shouldLogVerbose as shouldLogVerbose$1, warn } from "openclaw/plugin-sdk/runtime-env";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
 import { LocalMediaAccessError, getDefaultLocalRoots, loadWebMedia as loadWebMedia$1, loadWebMediaRaw, optimizeImageToJpeg, optimizeImageToPng } from "openclaw/plugin-sdk/web-media";
-import { createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-message";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId as normalizeAccountId$1, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { createChannelMessageReplyPipeline, createDurableInboundReceiveJournal, createMessageReceiptFromOutboundResults, deliverInboundReplyWithMessageSendContext, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-message";
 import { chunkMarkdownTextWithMode } from "openclaw/plugin-sdk/reply-chunking";
 import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, DEFAULT_MAIN_KEY, buildAgentMainSessionKey, buildAgentSessionKey, buildGroupHistoryKey, deriveLastRoutePolicy, normalizeAccountId as normalizeAccountId$1, normalizeAgentId, resolveAgentRoute, resolveInboundLastRouteSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { recordInboundSession } from "openclaw/plugin-sdk/conversation-runtime";
 import { loadSessionStore, resolveStorePath, updateLastRoute, updateSessionStore } from "openclaw/plugin-sdk/session-store-runtime";
 import { DisconnectReason as DisconnectReason$1, downloadMediaMessage, isJidGroup, normalizeMessageContent as normalizeMessageContent$1 } from "baileys";
 import { formatLocationText, resolveInboundSessionEnvelopeContext } from "openclaw/plugin-sdk/channel-inbound";
 import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import { createHash } from "node:crypto";
 import { dispatchReplyWithBufferedBlockDispatcher, finalizeInboundContext, resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-runtime";
+import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";
 import { createInboundDebouncer, resolveInboundDebounceMs } from "openclaw/plugin-sdk/channel-inbound-debounce";
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
 import { hasControlCommand, isControlCommandMessage, isControlCommandMessage as isControlCommandMessage$1, shouldComputeCommandAuthorized } from "openclaw/plugin-sdk/command-detection";
 import { drainPendingDeliveries } from "openclaw/plugin-sdk/delivery-queue-runtime";
 import { DEFAULT_GROUP_HISTORY_LIMIT, buildHistoryContextFromEntries, buildInboundHistoryFromEntries, createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
@@ -119,8 +124,8 @@ function resetWebInboundDedupe() {
 	claimableInboundMessages.clearMemory();
 	recentOutboundMessages.clear();
 }
-async function claimRecentInboundMessage(key) {
-	return (await claimableInboundMessages.claim(key)).kind === "claimed";
+async function claimRecentInboundMessageDelivery(key) {
+	return (await claimableInboundMessages.claim(key)).kind;
 }
 async function commitRecentInboundMessage(key) {
 	await claimableInboundMessages.commit(key);
@@ -139,6 +144,42 @@ function isRecentOutboundMessage(params) {
 	return recentOutboundMessages.peek(key);
 }
 //#endregion
+//#region extensions/whatsapp/src/inbound/durable-receive.ts
+const WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES = 450;
+const WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES = 450;
+const WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS = 720 * 60 * 60 * 1e3;
+const WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS = 10080 * 60 * 1e3;
+function hashNamespacePart(value) {
+	return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+function createWhatsAppDurableInboundMessageId(params) {
+	return createHash("sha256").update(`${params.remoteJid}\n${params.id}`).digest("hex");
+}
+function serializeWhatsAppDurableInboundMessage(message) {
+	return JSON.parse(JSON.stringify(message, BufferJSON.replacer));
+}
+function deserializeWhatsAppDurableInboundMessage(message) {
+	return JSON.parse(JSON.stringify(message), BufferJSON.reviver);
+}
+function createWhatsAppDurableInboundReceiveJournal(accountId) {
+	const runtime = getWhatsAppRuntime();
+	const accountPart = hashNamespacePart(accountId);
+	return createDurableInboundReceiveJournal({
+		pendingStore: runtime.state.openKeyedStore({
+			namespace: `inbound.v1.pending.${accountPart}`,
+			maxEntries: WHATSAPP_DURABLE_INBOUND_PENDING_MAX_ENTRIES,
+			defaultTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS
+		}),
+		completedStore: runtime.state.openKeyedStore({
+			namespace: `inbound.v1.completed.${accountPart}`,
+			maxEntries: WHATSAPP_DURABLE_INBOUND_COMPLETED_MAX_ENTRIES,
+			defaultTtlMs: WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS
+		}),
+		pendingTtlMs: WHATSAPP_DURABLE_INBOUND_PENDING_TTL_MS,
+		completedTtlMs: WHATSAPP_DURABLE_INBOUND_COMPLETED_TTL_MS
+	});
+}
+//#endregion
 //#region extensions/whatsapp/src/inbound/lifecycle.ts
 function attachEmitterListener(emitter, event, listener) {
 	emitter.on(event, listener);
@@ -298,6 +339,7 @@ async function attachWebInboxToSocket(options) {
 	const selfIdentity = await readWebSelfIdentityForDecision(options.authDir, sock.user);
 	if (selfIdentity.outcome === "unstable") throw new WhatsAppAuthUnstableError("WhatsApp auth state is still stabilizing; retrying inbox attach.");
 	const self = selfIdentity.identity;
+	const durableInboundJournal = createWhatsAppDurableInboundReceiveJournal(options.accountId);
 	const inboundDebounceMs = Math.max(0, Math.trunc(options.debounceMs ?? 0));
 	const pendingDebounceKeys = /* @__PURE__ */ new Set();
 	const activeInboundFlushes = /* @__PURE__ */ new Set();
@@ -309,14 +351,17 @@ async function attachWebInboxToSocket(options) {
 		return `${msg.accountId}:${conversationKey}:${senderKey}`;
 	};
 	const shouldDebounceInboundMessage = (msg) => options.shouldDebounce?.(msg) ?? true;
-	const finalizeInboundDedupe = async (entries, error) => {
+	const finalizeInboundDelivery = async (entries, error) => {
 		const dedupeKeys = [...new Set(entries.map((entry) => entry.dedupeKey).filter(isNonEmptyString))];
-		if (dedupeKeys.length === 0) return;
+		const durableEntries = entries.filter((entry) => isNonEmptyString(entry.durableId));
+		const readReceiptEntries = entries.filter((entry) => Boolean(entry.readReceipt));
 		if (error instanceof WhatsAppRetryableInboundError) {
 			dedupeKeys.forEach((dedupeKey) => releaseRecentInboundMessage(dedupeKey, error));
+			await Promise.all(durableEntries.map((entry) => durableInboundJournal.release(entry.durableId, { lastError: formatError(error) })));
 			return;
 		}
-		await Promise.all(dedupeKeys.map((dedupeKey) => commitRecentInboundMessage(dedupeKey)));
+		await Promise.all([...dedupeKeys.map((dedupeKey) => commitRecentInboundMessage(dedupeKey)), ...durableEntries.map((entry) => durableInboundJournal.complete(entry.durableId, entry.readReceipt ? { metadata: { readReceipt: entry.readReceipt } } : void 0))]);
+		await Promise.all(readReceiptEntries.map((entry) => maybeMarkInboundAsRead(entry.readReceipt)));
 	};
 	const debouncer = createInboundDebouncer({
 		debounceMs: inboundDebounceMs,
@@ -334,7 +379,7 @@ async function attachWebInboxToSocket(options) {
 				try {
 					if (entries.length === 1) {
 						await options.onMessage(last);
-						await finalizeInboundDedupe(entries);
+						await finalizeInboundDelivery(entries);
 						return;
 					}
 					const mentioned = /* @__PURE__ */ new Set();
@@ -348,9 +393,9 @@ async function attachWebInboxToSocket(options) {
 						isBatched: true
 					};
 					await options.onMessage(combinedMessage);
-					await finalizeInboundDedupe(entries);
+					await finalizeInboundDelivery(entries);
 				} catch (error) {
-					await finalizeInboundDedupe(entries, error);
+					await finalizeInboundDelivery(entries, error);
 					throw error;
 				}
 			} finally {
@@ -537,21 +582,121 @@ async function attachWebInboxToSocket(options) {
 			access
 		};
 	};
-	const maybeMarkInboundAsRead = async (inbound) => {
-		const { id, remoteJid, participantJid, access } = inbound;
-		if (id && !access.isSelfChat && options.sendReadReceipts !== false) try {
-			await sock.readMessages([{
+	const buildReadReceiptTarget = (inbound) => inbound.id ? {
+		remoteJid: inbound.remoteJid,
+		id: inbound.id,
+		...inbound.participantJid ? { participant: inbound.participantJid } : {}
+	} : void 0;
+	const maybeMarkInboundAsRead = async (target) => {
+		if (!target || options.sendReadReceipts === false) return;
+		const { id, remoteJid, participant } = target;
+		try {
+			await (getCurrentSock() ?? sock).readMessages([{
 				remoteJid,
 				id,
-				participant: participantJid,
+				participant,
 				fromMe: false
 			}]);
-			const suffix = participantJid ? ` (participant ${participantJid})` : "";
+			const suffix = participant ? ` (participant ${participant})` : "";
 			logWhatsAppVerbose(options.verbose, `Marked message ${id} as read for ${remoteJid}${suffix}`);
 		} catch (err) {
 			logWhatsAppVerbose(options.verbose, `Failed to mark message ${id} read: ${String(err)}`);
 		}
-		else if (id && access.isSelfChat && options.verbose) logWhatsAppVerbose(options.verbose, `Self-chat mode: skipping read receipt for ${id}`);
+	};
+	const maybeLogSkippedSelfChatReadReceipt = (inbound, target) => {
+		if (target?.id && inbound.access.isSelfChat && options.verbose) logWhatsAppVerbose(options.verbose, `Self-chat mode: skipping read receipt for ${target.id}`);
+	};
+	const maybeMarkReadReceiptAfterCompletedDelivery = async (inbound, target) => {
+		if (inbound.access.isSelfChat) {
+			maybeLogSkippedSelfChatReadReceipt(inbound, target);
+			return;
+		}
+		await maybeMarkInboundAsRead(target);
+	};
+	const maybeMarkReadReceiptForSkippedAppend = async (inbound, target) => {
+		if (inbound.access.isSelfChat) {
+			maybeLogSkippedSelfChatReadReceipt(inbound, target);
+			return;
+		}
+		await maybeMarkInboundAsRead(target);
+	};
+	const completeUndeliverableDurableInbound = async (durableId, metadata) => {
+		if (!durableId) return;
+		await durableInboundJournal.complete(durableId, metadata?.readReceipt ? { metadata: { readReceipt: metadata.readReceipt } } : void 0);
+	};
+	const buildDurableInboundPayload = (msg, upsertType) => ({
+		message: serializeWhatsAppDurableInboundMessage(msg),
+		...upsertType ? { upsertType } : {},
+		receivedAt: Date.now()
+	});
+	const shouldSkipStaleAppend = (msg, upsertType) => {
+		if (upsertType !== "append") return false;
+		const APPEND_RECENT_GRACE_MS = 6e4;
+		const msgTsRaw = msg.messageTimestamp;
+		const msgTsNum = msgTsRaw != null ? Number(msgTsRaw) : NaN;
+		return (Number.isFinite(msgTsNum) ? msgTsNum * 1e3 : 0) < connectedAtMs - APPEND_RECENT_GRACE_MS;
+	};
+	const processDurableInboundMessage = async (msg, upsertType, stored) => {
+		const inbound = await normalizeInboundMessage(msg);
+		if (!inbound) {
+			if (stored) await completeUndeliverableDurableInbound(stored.id, stored.metadata);
+			return;
+		}
+		const readReceipt = stored?.metadata?.readReceipt ?? buildReadReceiptTarget(inbound);
+		const deliveryReadReceipt = inbound.access.isSelfChat ? void 0 : readReceipt;
+		if (!stored && shouldSkipStaleAppend(msg, upsertType)) {
+			await maybeMarkReadReceiptForSkippedAppend(inbound, readReceipt);
+			return;
+		}
+		let durableId = stored?.id ?? (inbound.id ? createWhatsAppDurableInboundMessageId({
+			remoteJid: inbound.remoteJid,
+			id: inbound.id
+		}) : void 0);
+		const durableMetadata = deliveryReadReceipt ? { readReceipt: deliveryReadReceipt } : void 0;
+		if (durableId && !stored) try {
+			const accepted = await durableInboundJournal.accept(durableId, buildDurableInboundPayload(msg, upsertType), {
+				metadata: durableMetadata,
+				receivedAt: inbound.messageTimestampMs
+			});
+			if (accepted.kind === "completed") {
+				await maybeMarkReadReceiptAfterCompletedDelivery(inbound, accepted.record.metadata?.readReceipt ?? deliveryReadReceipt);
+				return;
+			}
+			if (accepted.kind === "pending" && accepted.record.attempts === 0) return;
+		} catch (err) {
+			durableId = void 0;
+			const error = formatError(err);
+			inboundLogger.warn({ error }, "failed persisting durable WhatsApp inbound; delivering live");
+			inboundConsoleLog.warn(`Failed persisting durable WhatsApp inbound; delivering live: ${error}`);
+		}
+		const enriched = await enrichInboundMessage(msg);
+		if (!enriched) {
+			await completeUndeliverableDurableInbound(durableId, durableMetadata);
+			await maybeMarkReadReceiptAfterCompletedDelivery(inbound, deliveryReadReceipt);
+			return;
+		}
+		const dedupeKey = inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : "";
+		const dedupeClaim = dedupeKey ? await claimRecentInboundMessageDelivery(dedupeKey) : "claimed";
+		if (dedupeClaim !== "claimed") {
+			if (dedupeClaim === "duplicate") {
+				await completeUndeliverableDurableInbound(durableId, durableMetadata);
+				await maybeMarkReadReceiptAfterCompletedDelivery(inbound, deliveryReadReceipt);
+			}
+			return;
+		}
+		recordAcceptedInboundActivity(options.accountId);
+		await enqueueInboundMessage(msg, inbound, enriched, {
+			durableId,
+			readReceipt: deliveryReadReceipt
+		});
+	};
+	const replayPendingDurableInboundMessages = async () => {
+		const pending = await durableInboundJournal.pending();
+		for (const record of pending) await processDurableInboundMessage(deserializeWhatsAppDurableInboundMessage(record.payload.message), record.payload.upsertType, {
+			id: record.id,
+			payload: record.payload,
+			metadata: record.metadata
+		});
 	};
 	const enrichInboundMessage = async (msg) => {
 		const location = extractLocationData(msg.message ?? void 0);
@@ -590,7 +735,7 @@ async function attachWebInboxToSocket(options) {
 			mediaFileName
 		};
 	};
-	const enqueueInboundMessage = async (msg, inbound, enriched) => {
+	const enqueueInboundMessage = async (msg, inbound, enriched, durable) => {
 		const chatJid = inbound.remoteJid;
 		const sendComposing = async () => {
 			const currentSock = getCurrentSock();
@@ -668,7 +813,9 @@ async function attachWebInboxToSocket(options) {
 			mediaPath: enriched.mediaPath,
 			mediaType: enriched.mediaType,
 			mediaFileName: enriched.mediaFileName,
-			dedupeKey: inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : void 0
+			dedupeKey: inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : void 0,
+			durableId: durable.durableId,
+			readReceipt: durable.readReceipt
 		};
 		const debounceKey = buildInboundDebounceKey(inboundMessage);
 		if (debounceKey) {
@@ -695,21 +842,16 @@ async function attachWebInboxToSocket(options) {
 	const handleMessagesUpsert = async (upsert) => {
 		if (upsert.type !== "notify" && upsert.type !== "append") return;
 		for (const msg of upsert.messages ?? []) {
-			const inbound = await normalizeInboundMessage(msg);
-			if (!inbound) continue;
-			await maybeMarkInboundAsRead(inbound);
-			if (upsert.type === "append") {
-				const APPEND_RECENT_GRACE_MS = 6e4;
-				const msgTsRaw = msg.messageTimestamp;
-				const msgTsNum = msgTsRaw != null ? Number(msgTsRaw) : NaN;
-				if ((Number.isFinite(msgTsNum) ? msgTsNum * 1e3 : 0) < connectedAtMs - APPEND_RECENT_GRACE_MS) continue;
-			}
-			const enriched = await enrichInboundMessage(msg);
-			if (!enriched) continue;
-			const dedupeKey = inbound.id ? `${options.accountId}:${inbound.remoteJid}:${inbound.id}` : "";
-			if (dedupeKey && !await claimRecentInboundMessage(dedupeKey)) continue;
-			recordAcceptedInboundActivity(options.accountId);
-			await enqueueInboundMessage(msg, inbound, enriched);
+			if (await maybeResolveWhatsAppApprovalReaction({
+				cfg: options.loadConfig?.() ?? options.cfg,
+				accountId: options.accountId,
+				msg,
+				selfJid: self.jid,
+				selfLid: self.lid,
+				resolveInboundJid,
+				logVerboseMessage: (message) => logWhatsAppVerbose(options.verbose, message)
+			})) continue;
+			await processDurableInboundMessage(msg, upsert.type);
 		}
 	};
 	const handleMessagesUpsertEvent = (upsert) => {
@@ -773,6 +915,14 @@ async function attachWebInboxToSocket(options) {
 	};
 	const detachMessagesUpsert = attachEmitterListener(sock.ev, "messages.upsert", handleMessagesUpsertEvent);
 	const detachConnectionUpdate = attachEmitterListener(sock.ev, "connection.update", handleConnectionUpdate);
+	const replayTask = replayPendingDurableInboundMessages().catch((err) => {
+		inboundLogger.error({ error: String(err) }, "failed replaying durable WhatsApp inbound");
+		inboundConsoleLog.error(`Failed replaying durable WhatsApp inbound: ${String(err)}`);
+	});
+	pendingMessageHandlers.add(replayTask);
+	replayTask.finally(() => {
+		pendingMessageHandlers.delete(replayTask);
+	});
 	(async () => {
 		try {
 			const groups = await sock.groupFetchAllParticipating();
@@ -1496,6 +1646,21 @@ function createWhatsAppReplyDeliveryReceipt(results) {
 		kind: resolveWhatsAppReceiptKind(results)
 	});
 }
+function markWhatsAppVisibleDeliveryError(error) {
+	if (typeof error === "object" && error !== null && !Array.isArray(error)) try {
+		Object.assign(error, {
+			sentBeforeError: true,
+			visibleReplySent: true
+		});
+		return error;
+	} catch {}
+	const visibleError = new Error("visible WhatsApp reply delivery failed", { cause: error });
+	Object.assign(visibleError, {
+		sentBeforeError: true,
+		visibleReplySent: true
+	});
+	return visibleError;
+}
 async function deliverWebReply(params) {
 	const { replyResult, msg, maxMediaBytes, textLimit, replyLogger, connectionId, skipLog } = params;
 	const replyStarted = Date.now();
@@ -1531,13 +1696,18 @@ async function deliverWebReply(params) {
 		});
 	};
 	const sendWithRetry = async (fn, label, maxAttempts = 3) => {
-		return await sendWhatsAppOutboundWithRetry({
-			send: fn,
-			maxAttempts,
-			onRetry: ({ attempt, maxAttempts: retryMaxAttempts, backoffMs, errorText }) => {
-				logVerbose(`Retrying ${label} to ${msg.from} after failure (${attempt}/${retryMaxAttempts - 1}) in ${backoffMs}ms: ${errorText}`);
-			}
-		});
+		try {
+			return await sendWhatsAppOutboundWithRetry({
+				send: fn,
+				maxAttempts,
+				onRetry: ({ attempt, maxAttempts: retryMaxAttempts, backoffMs, errorText }) => {
+					logVerbose(`Retrying ${label} to ${msg.from} after failure (${attempt}/${retryMaxAttempts - 1}) in ${backoffMs}ms: ${errorText}`);
+				}
+			});
+		} catch (error) {
+			if (sendResults.some((result) => result.providerAccepted)) throw markWhatsAppVisibleDeliveryError(error);
+			throw error;
+		}
 	};
 	if (mediaList.length === 0 && textChunks.length) {
 		const totalChunks = textChunks.length;
@@ -1679,9 +1849,42 @@ function resolveVisibleWhatsAppReplyContext(params) {
 }
 //#endregion
 //#region extensions/whatsapp/src/auto-reply/monitor/inbound-dispatch.ts
+function normalizeErrForLog(err) {
+	if (err instanceof Error) return {
+		...Object.fromEntries(Object.entries(err)),
+		type: err.name,
+		message: err.message,
+		stack: err.stack
+	};
+	return err;
+}
+function whatsAppReplyDeliveryVisibility(visibleReplySent) {
+	return { visibleReplySent };
+}
+function whatsAppReplyDeliveryVisibilityFromDurableResult(result) {
+	return whatsAppReplyDeliveryVisibility(result.visibleReplySent === true);
+}
+function markWhatsAppReplyDeliveryErrorVisible(error) {
+	if (typeof error === "object" && error !== null && !Array.isArray(error)) try {
+		Object.assign(error, {
+			sentBeforeError: true,
+			visibleReplySent: true
+		});
+		return error;
+	} catch {}
+	const visibleError = new Error("visible WhatsApp reply delivery failed", { cause: error });
+	Object.assign(visibleError, {
+		sentBeforeError: true,
+		visibleReplySent: true
+	});
+	return visibleError;
+}
+function markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult) {
+	return flushResult.delivered > 0 ? markWhatsAppReplyDeliveryErrorVisible(error) : error;
+}
 function logWhatsAppReplyDeliveryError(params) {
 	params.replyLogger.error({
-		err: params.err,
+		err: normalizeErrForLog(params.err),
 		replyKind: params.info.kind,
 		correlationId: params.msg.id ?? null,
 		connectionId: params.connectionId,
@@ -1730,8 +1933,11 @@ function createWhatsAppMediaOnlyReplyCoalescer(params) {
 				flushResult.droppedDuplicateMedia += 1;
 				continue;
 			}
-			await params.deliver(candidate);
-			flushResult.delivered += 1;
+			try {
+				if ((await params.deliver(candidate)).visibleReplySent) flushResult.delivered += 1;
+			} catch (error) {
+				throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
+			}
 		}
 		return flushResult;
 	};
@@ -1895,7 +2101,7 @@ async function dispatchWhatsAppBufferedReply(params) {
 	let didLogHeartbeatStrip = false;
 	const deliverNormalizedPayload = async (normalizedDeliveryPayload, info) => {
 		const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-		if (!reply.hasMedia && !reply.text.trim()) return;
+		if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
 		if (!(await params.deliverReply({
 			replyResult: normalizedDeliveryPayload,
 			normalizedReplyResult: normalizedDeliveryPayload,
@@ -1918,7 +2124,7 @@ async function dispatchWhatsAppBufferedReply(params) {
 				from: params.msg.to,
 				replyKind: info.kind
 			}, "auto-reply was not accepted by WhatsApp provider");
-			return;
+			return whatsAppReplyDeliveryVisibility(false);
 		}
 		didSendReply = true;
 		const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
@@ -1929,9 +2135,10 @@ async function dispatchWhatsAppBufferedReply(params) {
 		});
 		const fromDisplay = params.msg.chatType === "group" ? params.conversationId : params.msg.from ?? "unknown";
 		if (shouldLogVerbose$1()) logVerbose$1(`Reply body: ${normalizedDeliveryPayload.text != null ? reply.text : "<media>"}${reply.hasMedia ? " (media)" : ""} -> ${fromDisplay}`);
+		return whatsAppReplyDeliveryVisibility(true);
 	};
 	const mediaOnlyCoalescer = createWhatsAppMediaOnlyReplyCoalescer({ deliver: async (pending) => {
-		await deliverNormalizedPayload(pending.payload, pending.info);
+		return await deliverNormalizedPayload(pending.payload, pending.info);
 	} });
 	if (statusReactionController) statusReactionController.setThinking();
 	const { queuedFinal, counts } = await dispatchReplyWithBufferedBlockDispatcher({
@@ -1948,45 +2155,53 @@ async function dispatchWhatsAppBufferedReply(params) {
 			},
 			deliver: async (payload, info) => {
 				const deliveryPayload = resolveWhatsAppDeliverablePayload(payload, info);
-				if (!deliveryPayload) return;
+				if (!deliveryPayload) return whatsAppReplyDeliveryVisibility(false);
 				const normalizedOutboundPayload = normalizeWhatsAppOutboundPayload(deliveryPayload, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
 				const normalizedDeliveryPayload = deliveryPayload.text === void 0 ? {
 					...normalizedOutboundPayload,
 					text: void 0
 				} : normalizedOutboundPayload;
 				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
-				if (!reply.hasMedia && !reply.text.trim()) return;
+				if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
 				if (!reply.hasMedia) {
-					logWhatsAppMediaOnlyFlushResult(await mediaOnlyCoalescer.flushAll());
-					const durable = await deliverInboundReplyWithMessageSendContext({
-						cfg: params.cfg,
-						channel: "whatsapp",
-						accountId: params.route.accountId,
-						agentId: params.route.agentId,
-						ctxPayload: params.context,
-						payload: normalizedDeliveryPayload,
-						info,
-						to: params.msg.from,
-						formatting: {
-							textLimit,
-							tableMode,
-							chunkMode
-						}
-					});
-					if (durable.status === "failed") throw durable.error;
-					if (durable.status === "handled_visible") {
-						didSendReply = true;
-						const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
-						params.rememberSentText(normalizedDeliveryPayload.text, {
-							combinedBody: params.context.Body,
-							combinedBodySessionKey: params.route.sessionKey,
-							logVerboseMessage: shouldLog
+					const flushResult = await mediaOnlyCoalescer.flushAll();
+					logWhatsAppMediaOnlyFlushResult(flushResult);
+					try {
+						const durable = await deliverInboundReplyWithMessageSendContext({
+							cfg: params.cfg,
+							channel: "whatsapp",
+							accountId: params.route.accountId,
+							agentId: params.route.agentId,
+							ctxPayload: params.context,
+							payload: normalizedDeliveryPayload,
+							info,
+							to: params.msg.from,
+							formatting: {
+								textLimit,
+								tableMode,
+								chunkMode
+							}
 						});
-						return;
+						if (durable.status === "failed") {
+							if (durable.sentBeforeError === true) throw markWhatsAppReplyDeliveryErrorVisible(durable.error);
+							throw durable.error;
+						}
+						if (durable.status === "handled_visible") {
+							didSendReply = true;
+							const shouldLog = normalizedDeliveryPayload.text ? true : void 0;
+							params.rememberSentText(normalizedDeliveryPayload.text, {
+								combinedBody: params.context.Body,
+								combinedBodySessionKey: params.route.sessionKey,
+								logVerboseMessage: shouldLog
+							});
+							return whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
+						}
+						if (durable.status === "handled_no_send") return flushResult.delivered > 0 ? whatsAppReplyDeliveryVisibility(true) : whatsAppReplyDeliveryVisibilityFromDurableResult(durable.delivery);
+						const delivery = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+						return flushResult.delivered > 0 && !delivery.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : delivery;
+					} catch (error) {
+						throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
 					}
-					if (durable.status === "handled_no_send") return;
-					await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-					return;
 				}
 				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
 				if (shouldDeferWhatsAppMediaOnlyPayload({
@@ -1999,10 +2214,21 @@ async function dispatchWhatsAppBufferedReply(params) {
 						mediaUrls,
 						payload: normalizedDeliveryPayload
 					});
-					return;
+					return whatsAppReplyDeliveryVisibility(false);
 				}
-				logWhatsAppMediaOnlyFlushResult(await mediaOnlyCoalescer.flushExceptDuplicateMedia(mediaUrls));
-				await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+				const flushResult = await mediaOnlyCoalescer.flushExceptDuplicateMedia(mediaUrls);
+				logWhatsAppMediaOnlyFlushResult(flushResult);
+				try {
+					const delivery = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
+					return flushResult.delivered > 0 && !delivery.visibleReplySent ? whatsAppReplyDeliveryVisibility(true) : delivery;
+				} catch (error) {
+					throw markWhatsAppReplyDeliveryErrorVisibleAfterFlush(error, flushResult);
+				}
+			},
+			onSettled: async () => {
+				const flushResult = await mediaOnlyCoalescer.flushAll();
+				logWhatsAppMediaOnlyFlushResult(flushResult);
+				return whatsAppReplyDeliveryVisibility(flushResult.delivered > 0);
 			},
 			onReplyStart: params.msg.sendComposing,
 			...statusReactionController ? {
@@ -2035,7 +2261,6 @@ async function dispatchWhatsAppBufferedReply(params) {
 			} } : {}
 		}
 	});
-	logWhatsAppMediaOnlyFlushResult(await mediaOnlyCoalescer.flushAll());
 	if (!hasVisibleInboundReplyDispatch({
 		queuedFinal,
 		counts
@@ -3054,6 +3279,14 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 				continue;
 			}
 			statusController.noteConnected();
+			const approvalContextLease = registerChannelRuntimeContext({
+				channelRuntime: tuning.channelRuntime,
+				channelId: "whatsapp",
+				accountId: account.accountId,
+				capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+				context: { accountId: account.accountId },
+				abortSignal
+			});
 			controller.setUnhandledRejectionCleanup(registerUnhandledRejectionHandler((reason) => {
 				if (!isLikelyWhatsAppCryptoError(reason)) return false;
 				const errorStr = formatError(reason);
@@ -3121,10 +3354,14 @@ async function monitorWebChannel(verbose, listenerFactory = attachWebInboxToSock
 			if (process.stdout.isTTY || process.stderr.isTTY) whatsappLog.raw("Ctrl+C to stop.");
 			if (!keepAlive) {
 				clearInterval(periodicDrainInterval);
+				approvalContextLease?.dispose();
 				await controller.shutdown();
 				return;
 			}
-			const reason = await controller.waitForClose().finally(() => clearInterval(periodicDrainInterval));
+			const reason = await controller.waitForClose().finally(() => {
+				clearInterval(periodicDrainInterval);
+				approvalContextLease?.dispose();
+			});
 			if (stopRequested() || sigintStop || reason === "aborted") {
 				await controller.shutdown();
 				break;

package/dist/{outbound-adapter-ltiZkW9L.js → outbound-adapter-BObZXXzU.js}

@@ -6,7 +6,7 @@ import { chunkText } from "openclaw/plugin-sdk/reply-chunking";
 //#region extensions/whatsapp/src/outbound-adapter.ts
 let whatsAppSendModulePromise;
 function loadWhatsAppSendModule() {
-	whatsAppSendModulePromise ??= import("./send-E_kMiuZP.js").then((n) => n.a);
+	whatsAppSendModulePromise ??= import("./send-C9jEw6hx.js").then((n) => n.a);
 	return whatsAppSendModulePromise;
 }
 function normalizeOutboundText(text) {

package/dist/outbound-payload-test-api.js

@@ -1,2 +1,2 @@
-import { t as whatsappOutbound } from "./outbound-adapter-ltiZkW9L.js";
+import { t as whatsappOutbound } from "./outbound-adapter-BObZXXzU.js";
 export { whatsappOutbound };

package/dist/{runtime-CboC4QhQ.js → runtime-BfAdAEYT.js}

@@ -1,8 +1,8 @@
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
 //#region extensions/whatsapp/src/runtime.ts
-const { setRuntime: setWhatsAppRuntime, getRuntime: getWhatsAppRuntime } = createPluginRuntimeStore({
+const { setRuntime: setWhatsAppRuntime, getRuntime: getWhatsAppRuntime, tryGetRuntime: getOptionalWhatsAppRuntime } = createPluginRuntimeStore({
 	pluginId: "whatsapp",
 	errorMessage: "WhatsApp runtime not initialized"
 });
 //#endregion
-export { setWhatsAppRuntime as n, getWhatsAppRuntime as t };
+export { getWhatsAppRuntime as n, setWhatsAppRuntime as r, getOptionalWhatsAppRuntime as t };