@openclaw/whatsapp 2026.8.1-beta.3 → 2026.8.1

package/dist/{monitor-IzwQKizW.js → monitor-CySzv38g.js}

@@ -1,21 +1,21 @@
-import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BX2fZUyR.js";
-import { c as normalizeWhatsAppPayloadTextPreservingIndentation, d as listWhatsAppSendResultMessageIds, f as mergeWhatsAppAcceptedSendError, g as withWhatsAppLogicalDeliveryActivity, h as rememberWhatsAppPartialSend, l as prepareWhatsAppOutboundMedia, m as rememberWhatsAppAcceptedSend, o as normalizeWhatsAppOutboundPayload, p as normalizeWhatsAppSendResult, r as sendReactionWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-CwvTU4RI.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CeKQbu_s.js";
+import { c as normalizeWhatsAppPayloadTextPreservingIndentation, d as listWhatsAppSendResultMessageIds, f as mergeWhatsAppAcceptedSendError, g as withWhatsAppLogicalDeliveryActivity, h as rememberWhatsAppPartialSend, l as prepareWhatsAppOutboundMedia, m as rememberWhatsAppAcceptedSend, o as normalizeWhatsAppOutboundPayload, p as normalizeWhatsAppSendResult, r as sendReactionWhatsApp, v as resolveWhatsAppReactionLevel } from "./send-C3S-NqyO.js";
 import { i as getWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
 import { a as markdownToWhatsAppChunks, c as toWhatsappJid, l as toWhatsappJidWithLid, n as isSelfChatMode, o as resolveEquivalentWhatsAppDirectChatJids, r as jidToE164, s as resolveJidToE164 } from "./targets-runtime-TMk0lGuy.js";
 import { t as normalizeE164 } from "./text-runtime-CaKLhowd.js";
-import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-DmFc_Cqi.js";
+import { a as cacheInboundMessageMeta, i as buildQuotedMessageOptions, n as resolveWhatsAppGroupSessionRoute, o as lookupInboundMessageMeta, r as resolveWhatsAppLegacyGroupSessionKey } from "./group-session-key-CH9jJIVQ.js";
 import { C as getMentionIdentities, D as getSenderIdentity, E as getSelfIdentity, O as identitiesOverlap, S as getComparableIdentityValues, T as getReplyContext, g as readWebSelfId, k as resolveComparableIdentity, o as getWebAuthAgeMs, r as WhatsAppAuthUnstableError, v as readWebSelfIdentityForDecision, w as getPrimaryIdentityId } from "./auth-store-CtpBqH5S.js";
 import { n as resolveWhatsAppGroupsConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { a as waitForWaConnection, c as isWhatsAppSocketOperationTimeoutError, d as withWhatsAppSocketOperationTimeout, l as resolveWhatsAppSocketOperationTimeoutMs, r as createWaSocket, s as createWhatsAppSocketOperationTimeoutAdapter, u as resolveWhatsAppSocketTiming } from "./socket-close-2T0_jZTN.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
 import { t as BufferJSON } from "./session.runtime-Nsqaehbd.js";
-import { _ as resolveInboundMediaMimetype, a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as projectWhatsAppInboundMessage, h as hasInboundUserContent, i as resolveWhatsAppOutboundMentions, l as extractExternalAdReplyContext, n as addWhatsAppOutboundMentionsToContent, o as describeReplyContext, p as extractText, r as mayContainWhatsAppOutboundMention, s as extractContactContext, t as createWebSendApi, u as extractLocationData } from "./send-api-obOSm2cC.js";
+import { _ as resolveInboundMediaMimetype, a as addWhatsAppImagePreviewFields, c as extractContextInfo, d as extractMediaKind, f as extractMentionedJids, g as projectWhatsAppInboundMessage, h as hasInboundUserContent, i as resolveWhatsAppOutboundMentions, l as extractExternalAdReplyContext, n as addWhatsAppOutboundMentionsToContent, o as describeReplyContext, p as extractText, r as mayContainWhatsAppOutboundMention, s as extractContactContext, t as createWebSendApi, u as extractLocationData } from "./send-api-C-FFC1p_.js";
 import { t as resolveWhatsAppRuntimeGroupPolicy } from "./runtime-group-policy-DeSRFXEV.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-CIYuBJrs.js";
-import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-Jyr1JaAK.js";
-import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-D3eAeB0i.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { n as maybeResolveWhatsAppApprovalReaction } from "./approval-reactions-rpaNVHzZ.js";
+import { t as maybeResolveWhatsAppQuestionReaction } from "./question-reactions-B9D6MHXZ.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { filterSupplementalContextItems, resolvePinnedMainDmOwnerFromAllowlist } from "openclaw/plugin-sdk/security-runtime";
 import { createAckReactionHandle, createStatusReactionController, logAckFailure, removeAckReactionHandleAfterReply, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
@@ -28,7 +28,7 @@ import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runt
 import { buildChannelInboundEventContext, createChannelPartialDeliveryError, filterChannelInboundQuoteContext, formatInboundEnvelope, formatInboundEnvelope as formatInboundEnvelope$1, formatInboundMediaUnavailableText, formatLocationText, formatMediaPlaceholderText, hasVisibleInboundReplyDispatch, isChannelPartialDeliveryError, readAgentRunTerminalOutcome, resolveInboundSessionEnvelopeContext, resolveInboundSupplementalSenderAllowed, runChannelInboundEvent, shouldDebounceTextInbound, toInboundMediaFactsWithMetadata, toLocationContext } from "openclaw/plugin-sdk/channel-inbound";
 import { bindIngressLifecycleToReplyOptions, createChannelIngressMonitor, createChannelMessageReplyPipeline, createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds, resolveChannelMessageSourceReplyDeliveryMode, resolveChannelStreamingBlockEnabled } from "openclaw/plugin-sdk/channel-outbound";
 import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
-import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
+import { isReasoningReplyPayload, resolveSendableOutboundReplyParts, resolveTextChunksWithFallback, sendMediaWithLeadingCaption } from "openclaw/plugin-sdk/reply-payload";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { DisconnectReason, downloadMediaMessage, isHostedLidUser, isHostedPnUser, isJidGroup, isJidGroup as isJidGroup$1, jidDecode, jidEncode, jidNormalizedUser, normalizeMessageContent as normalizeMessageContent$1 } from "baileys";
@@ -416,8 +416,7 @@ function readGroupMetadataCacheEntry(cache, jid) {
 function createWhatsAppGroupMetadataCacheOwner(params) {
 	const reconnectCache = params.reconnectCache ?? /* @__PURE__ */ new Map();
 	const localCache = /* @__PURE__ */ new Map();
-	const publishedJids = /* @__PURE__ */ new Set();
-	const invalidatedJids = /* @__PURE__ */ new Set();
+	const groupMetadataGenerations = /* @__PURE__ */ new Map();
 	const detachListeners = [];
 	let closed = false;
 	let started = false;
@@ -447,46 +446,51 @@ function createWhatsAppGroupMetadataCacheOwner(params) {
 	});
 	const rememberFullUpdate = (jid, meta) => {
 		if (closed) return;
+		groupMetadataGenerations.set(jid, {});
 		rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
-		publishedJids.add(jid);
-		invalidatedJids.delete(jid);
 		rememberGroupMetadataCacheEntry(reconnectCache, jid, summarizeForReconnect(meta));
 		localCache.delete(jid);
 	};
 	const forgetFullMetadata = (jid) => {
+		groupMetadataGenerations.set(jid, {});
 		params.baileysCache?.delete(jid);
 		reconnectCache.delete(jid);
 		localCache.delete(jid);
-		publishedJids.delete(jid);
-		invalidatedJids.add(jid);
 	};
 	const get = async (jid) => {
-		const cached = readGroupMetadataCacheEntry(localCache, jid);
-		if (cached) return cached;
-		try {
-			const hydratedEntry = params.baileysCache?.get(jid);
-			const providerMetadata = params.baileysCache ? readWhatsAppBaileysCacheEntry(params.baileysCache, jid) : void 0;
-			const hydratedMetadata = providerMetadata?.participants?.length ? providerMetadata : void 0;
-			const meta = hydratedMetadata ?? await (params.getCurrentSock() ?? params.sock).groupMetadata(jid);
-			if (!hydratedMetadata) rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
-			publishedJids.add(jid);
-			const entry = await summarize(meta);
-			if (hydratedMetadata && hydratedEntry) entry.expires = hydratedEntry.expiresAt;
-			rememberGroupMetadataCacheEntry(reconnectCache, jid, {
-				subject: entry.subject,
-				expires: entry.expires
-			});
-			rememberGroupMetadataCacheEntry(localCache, jid, entry);
-			return entry;
-		} catch (error) {
-			const hydrated = readGroupMetadataCacheEntry(reconnectCache, jid);
-			if (hydrated) {
-				rememberGroupMetadataCacheEntry(localCache, jid, hydrated);
-				params.logVerbose(`Using cached group metadata for ${jid} after fetch failure: ${String(error)}`);
-				return hydrated;
+		for (;;) {
+			if (closed) return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
+			const cached = readGroupMetadataCacheEntry(localCache, jid);
+			if (cached) return cached;
+			const generation = groupMetadataGenerations.get(jid);
+			try {
+				const hydratedEntry = params.baileysCache?.get(jid);
+				const providerMetadata = params.baileysCache ? readWhatsAppBaileysCacheEntry(params.baileysCache, jid) : void 0;
+				const hydratedMetadata = providerMetadata?.participants?.length ? providerMetadata : void 0;
+				const meta = hydratedMetadata ?? await (params.getCurrentSock() ?? params.sock).groupMetadata(jid);
+				if (closed || groupMetadataGenerations.get(jid) !== generation) continue;
+				const entry = await summarize(meta);
+				if (closed || groupMetadataGenerations.get(jid) !== generation) continue;
+				if (hydratedMetadata && hydratedEntry) entry.expires = hydratedEntry.expiresAt;
+				else rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
+				groupMetadataGenerations.set(jid, {});
+				rememberGroupMetadataCacheEntry(reconnectCache, jid, {
+					subject: entry.subject,
+					expires: entry.expires
+				});
+				rememberGroupMetadataCacheEntry(localCache, jid, entry);
+				return entry;
+			} catch (error) {
+				if (closed || groupMetadataGenerations.get(jid) !== generation) continue;
+				const hydrated = readGroupMetadataCacheEntry(reconnectCache, jid);
+				if (hydrated) {
+					rememberGroupMetadataCacheEntry(localCache, jid, hydrated);
+					params.logVerbose(`Using cached group metadata for ${jid} after fetch failure: ${String(error)}`);
+					return hydrated;
+				}
+				params.logVerbose(`Failed to fetch group metadata for ${jid}: ${String(error)}`);
+				return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
 			}
-			params.logVerbose(`Failed to fetch group metadata for ${jid}: ${String(error)}`);
-			return { expires: resolveGroupMetadataExpiresAt() ?? 0 };
 		}
 	};
 	const resolveOutboundMentions = async (jid, text) => {
@@ -544,10 +548,10 @@ function createWhatsAppGroupMetadataCacheOwner(params) {
 			try {
 				const groups = await params.sock.groupFetchAllParticipating();
 				if (closed) return;
-				for (const [jid, meta] of Object.entries(groups ?? {})) if (meta && !publishedJids.has(jid) && !invalidatedJids.has(jid)) {
+				for (const [jid, meta] of Object.entries(groups ?? {})) if (meta && !groupMetadataGenerations.has(jid)) {
 					rememberGroupMetadataCacheEntry(reconnectCache, jid, summarizeForReconnect(meta));
 					rememberWhatsAppBaileysCacheEntry(params.baileysCache, jid, meta, GROUP_META_TTL_MS);
-					publishedJids.add(jid);
+					groupMetadataGenerations.set(jid, {});
 				}
 				params.logVerbose(`Hydrated ${Object.keys(groups ?? {}).length} participating groups on connect`);
 			} catch (error) {
@@ -2713,6 +2717,11 @@ async function deliverWebReplyInActivityScope(params) {
 	const isGroupConversation = transport.conversationKind === "group";
 	const replyStarted = Date.now();
 	const sendResults = [];
+	const acceptedMediaUrls = /* @__PURE__ */ new Set();
+	const recordMediaAccepted = (mediaUrl) => {
+		acceptedMediaUrls.add(mediaUrl);
+		params.onMediaAccepted?.(mediaUrl);
+	};
 	const finishDelivery = () => {
 		const receipt = createWhatsAppReplyDeliveryReceipt(sendResults);
 		return {
@@ -2721,20 +2730,22 @@ async function deliverWebReplyInActivityScope(params) {
 			providerAccepted: sendResults.some((result) => result.providerAccepted)
 		};
 	};
-	const preserveAcceptedDeliveryError = (error, kind) => {
+	const preserveAcceptedDeliveryError = (error, kind, mediaUrl) => {
 		const sendKind = kind ?? sendResults[0]?.kind ?? "text";
-		if (isChannelPartialDeliveryError(error)) rememberWhatsAppPartialSend({
-			error,
-			kind: sendKind,
-			results: sendResults
-		});
+		if (isChannelPartialDeliveryError(error)) {
+			if (rememberWhatsAppPartialSend({
+				error,
+				kind: sendKind,
+				results: sendResults
+			}) && mediaUrl) recordMediaAccepted(mediaUrl);
+		}
 		return mergeWhatsAppAcceptedSendError({
 			error,
 			kind: sendKind,
 			results: sendResults
 		});
 	};
-	const rememberSendResult = (result) => {
+	const rememberSendResult = (result, mediaUrl) => {
 		if (!result) return;
 		try {
 			rememberWhatsAppAcceptedSend({
@@ -2745,6 +2756,8 @@ async function deliverWebReplyInActivityScope(params) {
 		} catch (error) {
 			if (sendResults.some((accepted) => accepted.providerAccepted)) throw preserveAcceptedDeliveryError(error, result.kind);
 			throw error;
+		} finally {
+			if (mediaUrl && sendResults.includes(result)) recordMediaAccepted(mediaUrl);
 		}
 	};
 	if (isReasoningReplyPayload(replyResult)) {
@@ -2754,7 +2767,8 @@ async function deliverWebReplyInActivityScope(params) {
 	const tableMode = params.tableMode ?? "code";
 	const chunkMode = params.chunkMode ?? "length";
 	const normalizedReply = params.normalizedReplyResult ?? normalizeWhatsAppOutboundPayload(replyResult, { normalizeText: normalizeWhatsAppPayloadTextPreservingIndentation });
-	const textChunks = markdownToWhatsAppChunks(normalizedReply.text ?? "", textLimit, tableMode, chunkMode);
+	const text = normalizedReply.text ?? "";
+	const textChunks = resolveTextChunksWithFallback(text, markdownToWhatsAppChunks(text, textLimit, tableMode, chunkMode));
 	const mediaList = normalizedReply.mediaUrls ?? [];
 	const getQuote = () => {
 		if (!replyResult.replyToId) return;
@@ -2768,7 +2782,7 @@ async function deliverWebReplyInActivityScope(params) {
 			media: cached?.media
 		});
 	};
-	const sendWithRetry = async (fn, label, kind) => {
+	const sendWithRetry = async (fn, label, kind, mediaUrl) => {
 		try {
 			return await sendWhatsAppOutboundWithRetry({
 				send: fn,
@@ -2777,7 +2791,7 @@ async function deliverWebReplyInActivityScope(params) {
 				}
 			});
 		} catch (error) {
-			if (isChannelPartialDeliveryError(error) || sendResults.some((result) => result.providerAccepted)) throw preserveAcceptedDeliveryError(error, kind);
+			if (isChannelPartialDeliveryError(error) || sendResults.some((result) => result.providerAccepted)) throw preserveAcceptedDeliveryError(error, kind, mediaUrl);
 			throw error;
 		}
 	};
@@ -2809,13 +2823,10 @@ async function deliverWebReplyInActivityScope(params) {
 		return delivery;
 	}
 	const remainingText = [...textChunks];
-	const leadingCaption = remainingText.shift() || "";
-	let acceptedIdsBeforeCurrentMedia = /* @__PURE__ */ new Set();
 	await sendMediaWithLeadingCaption({
 		mediaUrls: mediaList,
-		caption: leadingCaption,
+		caption: remainingText.shift() || "",
 		send: async ({ mediaUrl, caption }) => {
-			acceptedIdsBeforeCurrentMedia = new Set(sendResults.flatMap(listWhatsAppSendResultMessageIds));
 			const media = await prepareWhatsAppOutboundMedia(await loadWebMedia(mediaUrl, {
 				maxBytes: maxMediaBytes,
 				localRoots: params.mediaLocalRoots
@@ -2824,37 +2835,26 @@ async function deliverWebReplyInActivityScope(params) {
 				logVerbose(`Web auto-reply media size: ${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB`);
 				logVerbose(`Web auto-reply media source: ${mediaUrl} (kind ${media.kind})`);
 			}
-			if (media.kind === "image") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
-					image: media.buffer,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:image", "media"));
-			} else if (media.kind === "audio") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
-					audio: media.buffer,
-					ptt: true,
-					mimetype: media.mimetype
-				}, quote), "media:audio", "media"));
-				if (caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text", "text"));
-			} else if (media.kind === "video") {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
-					video: media.buffer,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:video", "media"));
-			} else {
-				const quote = getQuote();
-				rememberSendResult(await sendWithRetry(() => transport.sendMedia({
-					document: media.buffer,
-					fileName: media.fileName,
-					caption,
-					mimetype: media.mimetype
-				}, quote), "media:document", "media"));
-			}
+			const quote = getQuote();
+			const mediaContent = media.kind === "image" ? {
+				image: media.buffer,
+				caption
+			} : media.kind === "audio" ? {
+				audio: media.buffer,
+				ptt: true
+			} : media.kind === "video" ? {
+				video: media.buffer,
+				caption
+			} : {
+				document: media.buffer,
+				fileName: media.fileName,
+				caption
+			};
+			rememberSendResult(await sendWithRetry(() => transport.sendMedia({
+				...mediaContent,
+				mimetype: media.mimetype
+			}, quote), `media:${media.kind}`, "media", mediaUrl), mediaUrl);
+			if (media.kind === "audio" && caption) rememberSendResult(await sendWithRetry(() => transport.reply(caption, quote), "media:audio-text", "text"));
 			whatsappOutboundLog.info(`Sent media reply to ${conversationId} (${(media.buffer.length / (1024 * 1024)).toFixed(2)}MB)`);
 			replyLogger.info({
 				correlationId: transport.correlationId ?? newConnectionId(),
@@ -2869,7 +2869,7 @@ async function deliverWebReplyInActivityScope(params) {
 			}, "auto-reply sent (media)");
 		},
 		onError: async ({ error, mediaUrl, caption, isFirst }) => {
-			if (sendResults.some((result) => listWhatsAppSendResultMessageIds(result).some((messageId) => !acceptedIdsBeforeCurrentMedia.has(messageId)))) throw preserveAcceptedDeliveryError(error);
+			if (acceptedMediaUrls.has(mediaUrl)) throw preserveAcceptedDeliveryError(error);
 			whatsappOutboundLog.error(`Failed sending web media to ${conversationId}: ${formatError(error)}`);
 			replyLogger.warn({
 				err: error,
@@ -3072,9 +3072,6 @@ function resolveWhatsAppDeliverablePayload(payload, info) {
 	}
 	return payload;
 }
-function getWhatsAppPayloadMediaUrls(payload) {
-	return new Set(normalizeStringEntries([...Array.isArray(payload.mediaUrls) ? payload.mediaUrls : [], ...typeof payload.mediaUrl === "string" ? [payload.mediaUrl] : []]));
-}
 function hasWhatsAppMediaUrlOverlap(left, right) {
 	for (const url of left) if (right.has(url)) return true;
 	return false;
@@ -3122,16 +3119,28 @@ function createWhatsAppMediaOnlyReplyCoalescer(params) {
 			return finalization;
 		},
 		flushNonDuplicateMedia: (mediaUrls) => flushWhere((pending) => !hasWhatsAppMediaUrlOverlap(pending.mediaUrls, mediaUrls)),
-		dropDuplicateMedia(mediaUrls) {
+		supersedeMedia(mediaUrl) {
 			const flushResult = {
 				delivered: 0,
 				droppedDuplicateMedia: 0
 			};
 			const retained = [];
-			for (const pending of pendingMediaOnlyPayloads.splice(0)) if (hasWhatsAppMediaUrlOverlap(pending.mediaUrls, mediaUrls)) {
-				pending.resolveFinalization(whatsAppReplyDeliveryVisibility(false));
-				flushResult.droppedDuplicateMedia += 1;
-			} else retained.push(pending);
+			for (const pending of pendingMediaOnlyPayloads.splice(0)) {
+				if (pending.mediaUrls.delete(mediaUrl)) {
+					flushResult.droppedDuplicateMedia += 1;
+					const mediaUrls = [...pending.mediaUrls];
+					pending.payload = {
+						...pending.payload,
+						mediaUrl: mediaUrls[0],
+						mediaUrls
+					};
+				}
+				if (pending.mediaUrls.size === 0) {
+					pending.resolveFinalization(whatsAppReplyDeliveryVisibility(false));
+					continue;
+				}
+				retained.push(pending);
+			}
 			pendingMediaOnlyPayloads.push(...retained);
 			return flushResult;
 		},
@@ -3140,7 +3149,7 @@ function createWhatsAppMediaOnlyReplyCoalescer(params) {
 }
 function logWhatsAppMediaOnlyFlushResult(result) {
 	if (!shouldLogVerbose$1()) return;
-	if (result.droppedDuplicateMedia > 0) logVerbose$1(`Dropped ${result.droppedDuplicateMedia} deferred media-only WhatsApp reply payload(s) superseded by captioned media`);
+	if (result.droppedDuplicateMedia > 0) logVerbose$1(`Superseded ${result.droppedDuplicateMedia} deferred WhatsApp attachment(s) with accepted replacement media`);
 	if (result.delivered > 0) logVerbose$1(`Flushed ${result.delivered} deferred media-only WhatsApp reply payload(s)`);
 }
 function resolveWhatsAppResponsePrefix(params) {
@@ -3202,7 +3211,8 @@ async function prepareWhatsAppInboundContext(params) {
 		from: conversationId,
 		sender: {
 			id: params.sender.id ?? params.sender.e164,
-			name: params.sender.name
+			name: params.sender.name,
+			isSelf: params.msg.platform.fromMe === true
 		},
 		conversation: {
 			kind: conversationKind,
@@ -3330,7 +3340,8 @@ function createWhatsAppReplyPlan(params) {
 				replyLogger: params.replyLogger,
 				connectionId: params.connectionId,
 				skipLog: false,
-				tableMode
+				tableMode,
+				onMediaAccepted: options?.onMediaAccepted
 			});
 		} catch (error) {
 			if (isWhatsAppVisibleDeliveryError(error) && !isChannelPartialDeliveryError(error)) throw createChannelPartialDeliveryError(error, {
@@ -3392,7 +3403,7 @@ function createWhatsAppReplyPlan(params) {
 				} : normalizedOutboundPayload;
 				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
 				if (!reply.hasMedia && !reply.text.trim()) return normalizedDeliveryPayload;
-				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
+				const mediaUrls = new Set(normalizedDeliveryPayload.mediaUrls);
 				logWhatsAppMediaOnlyFlushResult(reply.hasMedia ? shouldDeferWhatsAppMediaOnlyPayload({
 					info,
 					mediaUrls,
@@ -3426,7 +3437,7 @@ function createWhatsAppReplyPlan(params) {
 				const reply = resolveSendableOutboundReplyParts(normalizedDeliveryPayload);
 				if (!reply.hasMedia && !reply.text.trim()) return whatsAppReplyDeliveryVisibility(false);
 				if (!reply.hasMedia) return await deliverNormalizedPayload(normalizedDeliveryPayload, info, { recordDelivery: false });
-				const mediaUrls = getWhatsAppPayloadMediaUrls(normalizedDeliveryPayload);
+				const mediaUrls = new Set(normalizedDeliveryPayload.mediaUrls);
 				if (shouldDeferWhatsAppMediaOnlyPayload({
 					info,
 					mediaUrls,
@@ -3439,14 +3450,10 @@ function createWhatsAppReplyPlan(params) {
 						payload: normalizedDeliveryPayload
 					})
 				};
-				try {
-					const result = await deliverNormalizedPayload(normalizedDeliveryPayload, info);
-					if (result.visibleReplySent) logWhatsAppMediaOnlyFlushResult(mediaOnlyCoalescer.dropDuplicateMedia(mediaUrls));
-					return result;
-				} catch (error) {
-					if (isWhatsAppVisibleDeliveryError(error)) logWhatsAppMediaOnlyFlushResult(mediaOnlyCoalescer.dropDuplicateMedia(mediaUrls));
-					throw error;
-				}
+				return await deliverNormalizedPayload(normalizedDeliveryPayload, info, { onMediaAccepted: (mediaUrl) => {
+					didSendReply = true;
+					logWhatsAppMediaOnlyFlushResult(mediaOnlyCoalescer.supersedeMedia(mediaUrl));
+				} });
 			},
 			onDelivered: (payload, _info, result) => {
 				if (!resolveSendableOutboundReplyParts(payload).hasMedia && result?.visibleReplySent === true) recordDeliveredPayload(payload);

package/dist/{question-reactions-D3eAeB0i.js → question-reactions-B9D6MHXZ.js}

@@ -1,5 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-BX2fZUyR.js";
+import { a as resolveWhatsAppAccount } from "./accounts-CeKQbu_s.js";
 import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 //#region extensions/whatsapp/src/question-reactions.ts
 var question_reactions_exports = /* @__PURE__ */ __exportAll({

package/dist/runtime-api.js

@@ -1,16 +1,16 @@
 import { c as resolveWebCredsPath, r as hasWebCredsSync, s as resolveWebCredsBackupPath } from "./creds-files-W6B3EMZ8.js";
-import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-pM-ExU0l.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-CwvTU4RI.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-YA_Yvunu.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-C3S-NqyO.js";
 import { a as setWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
-import { t as createWhatsAppLoginTool } from "./agent-tools-login-BjRpD-JQ.js";
+import { t as createWhatsAppLoginTool } from "./agent-tools-login-B-2qZPzc.js";
 import { M as waitForCredsSaveQueueWithTimeout, N 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, j as waitForCredsSaveQueue, 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, x as webAuthExists, y as resolveDefaultWebAuthDir } from "./auth-store-CtpBqH5S.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
 import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-BEjWsCNM.js";
 import { a as waitForWaConnection, i as newConnectionId, r as createWaSocket } from "./socket-close-2T0_jZTN.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { p as extractText, s as extractContactContext, u as extractLocationData } from "./send-api-obOSm2cC.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-IzwQKizW.js";
-import { t as loginWeb } from "./login-BkpKpndm.js";
+import { p as extractText, s as extractContactContext, u as extractLocationData } from "./send-api-C-FFC1p_.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-CySzv38g.js";
+import { t as loginWeb } from "./login-1u5WcfTn.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, 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-CwvTU4RI.js → send-C3S-NqyO.js}

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BX2fZUyR.js";
+import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CeKQbu_s.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-CugRyONv.js";
 import { r as getWhatsAppConnectionController } from "./connection-controller-runtime-context-DG0tuYuw.js";
@@ -496,7 +496,7 @@ async function sendMessageWhatsAppInActivityScope(to, body, options) {
 	const accountIdForFormatting = resolvedAccountId ?? options.accountId;
 	const textLimit = Math.min(resolveTextChunkLimit(cfg, "whatsapp", accountIdForFormatting, { fallbackLimit: 4e3 }), 4096);
 	const textChunks = markdownToWhatsAppChunks(text, textLimit, tableMode, resolveChunkMode(cfg, "whatsapp", accountIdForFormatting));
-	text = textChunks.shift() ?? "";
+	text = textChunks.shift() ?? text;
 	if (!text && !hasMedia) return {
 		messageId: "",
 		toJid: jid

package/dist/{send-api-obOSm2cC.js → send-api-C-FFC1p_.js}

@@ -1,9 +1,9 @@
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-CugRyONv.js";
-import { _ as resolveWhatsAppDocumentFileName, f as mergeWhatsAppAcceptedSendError, m as rememberWhatsAppAcceptedSend, p as normalizeWhatsAppSendResult, u as combineWhatsAppSendResults } from "./send-CwvTU4RI.js";
+import { _ as resolveWhatsAppDocumentFileName, f as mergeWhatsAppAcceptedSendError, m as rememberWhatsAppAcceptedSend, p as normalizeWhatsAppSendResult, u as combineWhatsAppSendResults } from "./send-C3S-NqyO.js";
 import "./normalize-C7Hkc_vE.js";
 import { c as toWhatsappJid, l as toWhatsappJidWithLid, r as jidToE164 } from "./targets-runtime-TMk0lGuy.js";
 import "./text-runtime-CaKLhowd.js";
-import { i as buildQuotedMessageOptions } from "./group-session-key-DmFc_Cqi.js";
+import { i as buildQuotedMessageOptions } from "./group-session-key-CH9jJIVQ.js";
 import { k as resolveComparableIdentity } from "./auth-store-CtpBqH5S.js";
 import { isRecord, normalizeLowercaseStringOrEmpty, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -401,7 +401,7 @@ async function addWhatsAppImagePreviewFields(content) {
 //#endregion
 //#region extensions/whatsapp/src/inbound/outbound-mentions.ts
 const CODE_FENCE_RE = /```[\s\S]*?```/g;
-const INLINE_CODE_RE = /`[^`\n]+`/g;
+const INLINE_CODE_RE = /(?<=(?:^|[^\\])(?:\\\\)*)(`+)[\s\S]*?(?:(?<!`)\1(?!`)|$)/g;
 const OUTBOUND_MENTION_RE = /@(\+?\d+)/g;
 const KNOWN_USER_JID_RE = /^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted|lid|hosted\.lid|c\.us)$/i;
 const PHONE_JID_DOMAIN_RE = /^(s\.whatsapp\.net|hosted|c\.us)$/i;

package/dist/{setup-finalize-n4K2I2gJ.js → setup-finalize-CRzMpx84.js}

@@ -1,10 +1,10 @@
-import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-BX2fZUyR.js";
+import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./accounts-CeKQbu_s.js";
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
 import { r as hasWebCredsSync } from "./creds-files-W6B3EMZ8.js";
 import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-CugRyONv.js";
-import { r as whatsappSetupAdapter } from "./shared-wg42NKFB.js";
-import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
+import { r as whatsappSetupAdapter } from "./shared-D3B14d45.js";
 import { formatCliCommand, formatDocsLink } from "openclaw/plugin-sdk/setup-tools";
+import { DEFAULT_ACCOUNT_ID, createSetupTranslator, splitSetupEntries } from "openclaw/plugin-sdk/setup";
 //#region extensions/whatsapp/src/setup-finalize.ts
 const t = createSetupTranslator();
 function trimPromptText(value) {
@@ -295,7 +295,7 @@ async function finalizeWhatsAppSetup(params) {
 		};
 		let loginWeb;
 		try {
-			({loginWeb} = await import("./login-BkpKpndm.js").then((n) => n.n));
+			({loginWeb} = await import("./login-1u5WcfTn.js").then((n) => n.n));
 		} catch (error) {
 			await reportLoginFailure(error);
 		}

package/dist/setup-plugin-api.js

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

package/dist/{setup-surface-Cwn3zyxK.js → setup-surface-ym4doiv3.js}

@@ -1,4 +1,4 @@
-import { o as resolveWhatsAppAuthDir } from "./accounts-BX2fZUyR.js";
+import { o as resolveWhatsAppAuthDir } from "./accounts-CeKQbu_s.js";
 import { t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { a as formatWhatsAppWebAuthStatusState, h as readWebAuthState } from "./auth-store-CtpBqH5S.js";
 import { DEFAULT_ACCOUNT_ID, createSetupTranslator, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
@@ -36,7 +36,7 @@ const whatsappSetupWizard = {
 	},
 	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
 	credentials: [],
-	finalize: async (params) => await (await import("./setup-finalize-n4K2I2gJ.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-CRzMpx84.js")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/{shared-wg42NKFB.js → shared-D3B14d45.js}

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-BX2fZUyR.js";
+import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CeKQbu_s.js";
 import { r as resolveDefaultWhatsAppAccountId, t as listAccountIds } from "./account-ids-CB5SOWjc.js";
 import { a as normalizeWhatsAppAllowFromEntries } from "./normalize-target-CugRyONv.js";
 import { t as WhatsAppChannelConfigSchema } from "./config-schema-BQP5YCeK.js";
@@ -27,7 +27,7 @@ async function readWhatsAppAccountLinkState(authDir) {
 }
 const loadWhatsAppChannelRuntime = createLazyRuntimeModule(async () => {
 	await loadWhatsAppAuthStore();
-	return await import("./channel.runtime-X3JC2gaq.js");
+	return await import("./channel.runtime-D_PjmeMT.js");
 });
 //#endregion
 //#region extensions/whatsapp/src/config-accessors.ts
@@ -115,7 +115,7 @@ async function applyWhatsAppSecurityConfigFixes(params) {
 //#region extensions/whatsapp/src/shared.ts
 const WHATSAPP_CHANNEL = "whatsapp";
 async function loadWhatsAppSetupSurface() {
-	return await import("./setup-surface-Cwn3zyxK.js");
+	return await import("./setup-surface-ym4doiv3.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({

package/node_modules/baileys/lib/Defaults/index.js

@@ -2,7 +2,7 @@ import { proto } from '../../WAProto/index.js';
 import { makeLibSignalRepository } from '../Signal/libsignal.js';
 import { Browsers } from '../Utils/browser-utils.js';
 import logger from '../Utils/logger.js';
-const version = [2, 3000, 1035194821];
+const version = [2, 3000, 1043857760];
 export const UNAUTHORIZED_CODES = [401, 403, 419];
 export const DEFAULT_ORIGIN = 'https://web.whatsapp.com';
 export const CALL_VIDEO_PREFIX = 'https://call.whatsapp.com/video/';

package/node_modules/baileys/lib/Socket/business.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"business.d.ts","sourceRoot":"","sources":["../../src/Socket/business.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC5G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAUnE,OAAO,EAAE,KAAK,UAAU,EAAqC,MAAM,aAAa,CAAA;AAIhF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,YAAY;;+BA8Od,MAAM,eAAe,MAAM;yCAjGjB,iBAAiB;;;;2BAmD/B,MAAM;;;4BAkIL,aAAa;gCAwCT,MAAM,EAAE;;;+BA9ET,MAAM,UAAU,aAAa;kCAxR1B,0BAA0B;8BA2E9B,aAAa;2BAoChB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsSqvnB,CAAC;;;;;;;;;0DAhX9wnB,GAAG,0BAChB,GAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8WF,CAAA"}
+{"version":3,"file":"business.d.ts","sourceRoot":"","sources":["../../src/Socket/business.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAC5G,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,mBAAmB,CAAA;AAUnE,OAAO,EAAE,KAAK,UAAU,EAAqC,MAAM,aAAa,CAAA;AAIhF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,YAAY;;+BA8Od,MAAM,eAAe,MAAM;yCAjGjB,iBAAiB;;;;2BAmD/B,MAAM;;;4BAkIL,aAAa;gCAwCT,MAAM,EAAE;;;+BA9ET,MAAM,UAAU,aAAa;kCAxR1B,0BAA0B;8BA2E9B,aAAa;2BAoChB,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAsS6+nB,CAAC;;;;;;;;;0DAhXtgoB,GAAG,0BAChB,GAAH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8WF,CAAA"}

package/node_modules/baileys/lib/Socket/chats.d.ts

@@ -5,6 +5,7 @@ import type { QuickReplyAction } from '../Types/Bussines.js';
 import type { LabelActionBody } from '../Types/Label.js';
 import { type BinaryNode } from '../WABinary/index.js';
 import { USyncQuery } from '../WAUSync/index.js';
+export declare const buildProfilePictureQueryContent: (type: "preview" | "image", tcTokenContent?: BinaryNode[]) => BinaryNode[];
 export declare const makeChatsSocket: (config: SocketConfig) => {
     serverProps: {
         /** AB prop 10518: gate tctoken on 1:1 messages. Default true (safe: avoids 463). */

package/node_modules/baileys/lib/Socket/chats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chats.d.ts","sourceRoot":"","sources":["../../src/Socket/chats.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAE9C,OAAO,KAAK,EACX,WAAW,EACX,UAAU,EACV,gBAAgB,EAGhB,iBAAiB,EAEjB,YAAY,EAEZ,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,aAAa,EAEb,UAAU,EACV,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAqBrD,OAAO,EACN,KAAK,UAAU,EAWf,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,UAAU,EAAa,MAAM,YAAY,CAAA;AAGlD,eAAO,MAAM,eAAe,GAAI,QAAQ,YAAY;;QA8BlD,oFAAoF;;QAEpF,+EAA+E;;QAE/E,iFAAiF;;;2BAqqB9C,OAAO,GAAG,OAAO,UAAU;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,cAAc,MAAM;;;;;;;;;;;;;;;;;;4BA2HnE,aAAa;+BArGV,UAAU,UAAU,MAAM;+BA8C1B,MAAM;6BA5GR,MAAM,SAAQ,SAAS,GAAG,OAAO,cAA0B,MAAM;;2BAjdnE,MAAM,EAAE;yCAaM,MAAM,EAAE;gCAepD,MAAM,WACF,aAAa,eACT;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;gCAmCN,MAAM;kCA0BJ,MAAM;8BAkBV,MAAM;6BAkBP,MAAM,UAAU,OAAO,GAAG,SAAS;2DAooBX,OAAO;+BAr1B7B,kBAAkB;mCAJd,sBAAsB;mCAQtB,cAAc;iCAIhB,oBAAoB;yCAIZ,cAAc;iCAItB,cAAc;uCAIR,mBAAmB;oCAItB,sBAAsB;8CAIZ,MAAM;8BAqPtB,MAAM,KAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;;sBA4jBxD,gBAAgB,OAAO,MAAM;2BA1gBlB,cAAc,GAAG,QAAQ,kBAAkB,MAAM,GAAG,MAAM;4BA6iB/D,MAAM,WAAW,KAAK,CAAC,eAAe,CAAC,cAAc;yBAYxD,MAAM;;oBAYX,MAAM,UAAU,eAAe;wBAc3B,MAAM,WAAW,MAAM;2BAcpB,MAAM,WAAW,MAAM;2BAcvB,MAAM,aAAa,MAAM,WAAW,MAAM;8BAevC,MAAM,aAAa,MAAM,WAAW,MAAM;gBAhGxD,MAAM,YAAY;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,QAAQ,OAAO;sCA+G7C,gBAAgB;kCAYpB,MAAM;;;;;;0DAxlC5B,GAAG,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi7C/C,CAAA"}
+{"version":3,"file":"chats.d.ts","sourceRoot":"","sources":["../../src/Socket/chats.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAA;AACjC,OAAO,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAA;AAE9C,OAAO,KAAK,EACX,WAAW,EACX,UAAU,EACV,gBAAgB,EAGhB,iBAAiB,EAEjB,YAAY,EAEZ,iBAAiB,EACjB,aAAa,EACb,SAAS,EACT,aAAa,EAEb,UAAU,EACV,kBAAkB,EAClB,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACpB,cAAc,EACd,mBAAmB,EACnB,MAAM,UAAU,CAAA;AAEjB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAA;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAqBrD,OAAO,EACN,KAAK,UAAU,EAWf,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,UAAU,EAAa,MAAM,YAAY,CAAA;AAGlD,eAAO,MAAM,+BAA+B,GAC3C,MAAM,SAAS,GAAG,OAAO,EACzB,iBAAiB,UAAU,EAAE,KAC3B,UAAU,EAOZ,CAAA;AAED,eAAO,MAAM,eAAe,GAAI,QAAQ,YAAY;;QA8BlD,oFAAoF;;QAEpF,+EAA+E;;QAE/E,iFAAiF;;;2BAkqB9C,OAAO,GAAG,OAAO,UAAU;QAAE,SAAS,EAAE,MAAM,CAAA;KAAE,cAAc,MAAM;;;;;;;;;;;;;;;;;;4BA2HnE,aAAa;+BArGV,UAAU,UAAU,MAAM;+BA8C1B,MAAM;6BAzGR,MAAM,SAAQ,SAAS,GAAG,OAAO,cAA0B,MAAM;;2BAjdnE,MAAM,EAAE;yCAaM,MAAM,EAAE;gCAepD,MAAM,WACF,aAAa,eACT;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;gCAmCN,MAAM;kCA0BJ,MAAM;8BAkBV,MAAM;6BAkBP,MAAM,UAAU,OAAO,GAAG,SAAS;2DAioBX,OAAO;+BAl1B7B,kBAAkB;mCAJd,sBAAsB;mCAQtB,cAAc;iCAIhB,oBAAoB;yCAIZ,cAAc;iCAItB,cAAc;uCAIR,mBAAmB;oCAItB,sBAAsB;8CAIZ,MAAM;8BAqPtB,MAAM,KAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;;sBAyjBxD,gBAAgB,OAAO,MAAM;2BAvgBlB,cAAc,GAAG,QAAQ,kBAAkB,MAAM,GAAG,MAAM;4BA0iB/D,MAAM,WAAW,KAAK,CAAC,eAAe,CAAC,cAAc;yBAYxD,MAAM;;oBAYX,MAAM,UAAU,eAAe;wBAc3B,MAAM,WAAW,MAAM;2BAcpB,MAAM,WAAW,MAAM;2BAcvB,MAAM,aAAa,MAAM,WAAW,MAAM;8BAevC,MAAM,aAAa,MAAM,WAAW,MAAM;gBAhGxD,MAAM,YAAY;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,EAAE,QAAQ,OAAO;sCA+G7C,gBAAgB;kCAYpB,MAAM;;;;;;0DAjmC5B,GAAG,0BAA0B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA07C/C,CAAA"}