@openclaw/whatsapp 2026.7.2-beta.5 → 2026.7.2-beta.7

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-B2bNDUwE.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-BTXJAyK4.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-BzfDFPbH.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-D37ddk22.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-DfyToBpG.js";
+import { t as createWhatsAppLoginTool } from "./agent-tools-login-DE9MU98T.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-DcEpIOmE.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-DridEuzz.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-JuazczrA.js";
-import { g as extractLocationData, p as extractContactContext, y as extractText } from "./send-api-BY_AkSiB.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-B7phZF9w.js";
+import { g as extractLocationData, p as extractContactContext, y as extractText } from "./send-api-7wk6eQyW.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-CfkaUSL2.js";
 import { t as loginWeb } from "./login-CvY2Dhch.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-BTXJAyK4.js → send-D37ddk22.js}

@@ -18,7 +18,7 @@ import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime"
 import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
 import { resolveChunkMode, resolveTextChunkLimit } from "openclaw/plugin-sdk/reply-chunking";
 import { createSubsystemLogger, getChildLogger as getChildLogger$1 } from "openclaw/plugin-sdk/runtime-env";
-import { extensionForMime, mediaKindFromMime, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
+import { extensionForMime, mediaKindFromMime, mimeTypeFromFilePath, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
 import { sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
 import { MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS, transcodeAudioBufferToOpus } from "openclaw/plugin-sdk/media-runtime";
 import { resolveOutboundMediaUrls } from "openclaw/plugin-sdk/reply-payload";
@@ -92,17 +92,22 @@ function normalizeWhatsAppOutboundPayload(payload, options) {
 		mediaUrls: mediaUrls.length > 0 ? mediaUrls : void 0
 	};
 }
-function inferWhatsAppMediaKind(media) {
-	if (media.kind === "image" || media.kind === "audio" || media.kind === "video" || media.kind === "document") return media.kind;
-	const inferredKind = mediaKindFromMime(normalizeMimeType(media.contentType));
+function inferWhatsAppMediaKind(media, resolvedContentType) {
+	const isGenericDocument = media.kind === "document" && normalizeMimeType(media.contentType) === "application/octet-stream";
+	if (media.kind === "image" || media.kind === "audio" || media.kind === "video" || media.kind === "document" && !isGenericDocument) return media.kind;
+	const inferredKind = mediaKindFromMime(normalizeMimeType(resolvedContentType));
 	return !inferredKind || inferredKind === "sticker" || inferredKind === "unknown" ? "document" : inferredKind;
 }
 function normalizeWhatsAppLoadedMedia(media, mediaUrl) {
-	const kind = inferWhatsAppMediaKind(media);
+	const filenameMimeType = mimeTypeFromFilePath(media.fileName);
+	const normalizedContentType = normalizeMimeType(media.contentType);
+	const resolvedContentType = !normalizedContentType || normalizedContentType === "application/octet-stream" ? filenameMimeType ?? media.contentType : media.contentType;
+	const kind = inferWhatsAppMediaKind(media, resolvedContentType);
 	const mimetype = kind === "audio" && isWhatsAppNativeVoiceAudio({
 		contentType: media.contentType,
+		fileName: media.fileName,
 		mediaUrl
-	}) ? WHATSAPP_VOICE_MIMETYPE : media.contentType ?? "application/octet-stream";
+	}) ? WHATSAPP_VOICE_MIMETYPE : resolvedContentType ?? "application/octet-stream";
 	const fileName = kind === "document" ? resolveWhatsAppDocumentFileName({
 		fileName: media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl),
 		mimetype

package/dist/{send-api-BY_AkSiB.js → send-api-7wk6eQyW.js}

@@ -1,5 +1,5 @@
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-CugRyONv.js";
-import { l as resolveWhatsAppDocumentFileName } from "./send-BTXJAyK4.js";
+import { l as resolveWhatsAppDocumentFileName } from "./send-D37ddk22.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";
@@ -286,7 +286,17 @@ function describeReplyContext(rawMessage) {
 	if (!message) return null;
 	const contextInfo = extractContextInfo(message);
 	const quoted = normalizeMessageContent(contextInfo?.quotedMessage);
-	if (!quoted) return null;
+	if (!quoted && !contextInfo?.stanzaId) return null;
+	const senderJid = contextInfo?.participant ?? void 0;
+	const sender = resolveComparableIdentity({
+		jid: senderJid,
+		label: senderJid ? jidToE164(senderJid) ?? senderJid : "unknown sender"
+	});
+	if (!quoted) return {
+		id: contextInfo?.stanzaId || void 0,
+		body: "[quoted message unavailable]",
+		sender
+	};
 	const location = extractLocationData(quoted);
 	const locationText = location ? formatLocationText(location) : void 0;
 	const body = [extractText(quoted), locationText].filter(Boolean).join("\n").trim();
@@ -300,11 +310,6 @@ function describeReplyContext(rawMessage) {
 		logVerbose(`Quoted message missing extractable body${quotedType ? ` (type ${quotedType})` : ""}`);
 		return null;
 	}
-	const senderJid = contextInfo?.participant ?? void 0;
-	const sender = resolveComparableIdentity({
-		jid: senderJid,
-		label: senderJid ? jidToE164(senderJid) ?? senderJid : "unknown sender"
-	});
 	return {
 		id: contextInfo?.stanzaId || void 0,
 		body: body ?? "",

package/dist/{setup-finalize-C-m-vCl9.js → setup-finalize-BZucx24W.js}

@@ -2,7 +2,7 @@ import { a as resolveWhatsAppAccount, o as resolveWhatsAppAuthDir } from "./acco
 import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
 import { r as hasWebCredsSync } from "./creds-files-B1kSWtBg.js";
 import { a as normalizeWhatsAppAllowFromEntries, o as normalizeWhatsAppAllowFromEntry } from "./normalize-target-CugRyONv.js";
-import { r as whatsappSetupAdapter } from "./shared-UcAwtJaq.js";
+import { r as whatsappSetupAdapter } from "./shared-CAxd15bp.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

package/dist/setup-plugin-api.js

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

package/dist/{setup-surface-BjvUbR6M.js → setup-surface-BkVcd769.js}

@@ -36,7 +36,7 @@ const whatsappSetupWizard = {
 	},
 	resolveShouldPromptAccountIds: ({ shouldPromptAccountIds }) => shouldPromptAccountIds,
 	credentials: [],
-	finalize: async (params) => await (await import("./setup-finalize-C-m-vCl9.js")).finalizeWhatsAppSetup(params),
+	finalize: async (params) => await (await import("./setup-finalize-BZucx24W.js")).finalizeWhatsAppSetup(params),
 	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false),
 	onAccountRecorded: (accountId, options) => {
 		options?.onAccountId?.(channel, accountId);

package/dist/{shared-UcAwtJaq.js → shared-CAxd15bp.js}

@@ -1,7 +1,7 @@
 import { a as resolveWhatsAppAccount, n as hasAnyWhatsAppAuth } from "./accounts-CSqLvCY5.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-DARep0Nn.js";
+import { t as WhatsAppChannelConfigSchema } from "./config-schema-BQP5YCeK.js";
 import { n as whatsappDoctor } from "./doctor-CwzVXKoE.js";
 import { t as resolveWhatsAppConfigPath } from "./group-config-path-BGyzT9Lg.js";
 import { t as resolveLegacyGroupSessionKey } from "./group-session-contract-DDnZSsJ1.js";
@@ -14,19 +14,20 @@ import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { buildChannelGroupsScopeTree, collectOpenGroupPolicyRouteAllowlistWarnings, createAllowlistProviderGroupPolicyWarningCollector, resolveScopeRequireMention, resolveScopeToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { applyAccountNameToChannelSection, migrateBaseNameToDefaultAccount, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
+import { createPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup";
 import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
 import { createDelegatedSetupWizardProxy } from "openclaw/plugin-sdk/setup-runtime";
 import { readChannelAllowFromStore } from "openclaw/plugin-sdk/channel-pairing";
 //#region extensions/whatsapp/src/channel-runtime-loader.ts
 const loadWhatsAppAuthStore = createLazyRuntimeModule(() => import("./auth-store-DcEpIOmE.js").then((n) => n.i));
-async function isWhatsAppAuthConfigured(authDir) {
-	return await (await loadWhatsAppAuthStore()).readWebAuthState(authDir) === "linked";
+async function readWhatsAppAccountLinkState(authDir) {
+	const state = await (await loadWhatsAppAuthStore()).readWebAuthState(authDir);
+	return state === "unstable" ? "unknown" : state;
 }
 const loadWhatsAppChannelRuntime = createLazyRuntimeModule(async () => {
 	await loadWhatsAppAuthStore();
-	return await import("./channel.runtime-Q5fJ2I2b.js");
+	return await import("./channel.runtime-BP0xNmLi.js");
 });
 //#endregion
 //#region extensions/whatsapp/src/config-accessors.ts
@@ -52,51 +53,13 @@ function resolveWhatsAppGroupToolPolicy(params) {
 		messageProvider: "whatsapp"
 	});
 }
-//#endregion
-//#region extensions/whatsapp/src/setup-core.ts
-const channel = "whatsapp";
 const whatsappSetupAdapter = {
-	singleAccountKeysToMove: ["authDir"],
-	resolveAccountId: ({ accountId }) => normalizeAccountId$1(accountId),
-	applyAccountName: ({ cfg, accountId, name }) => applyAccountNameToChannelSection({
-		cfg,
-		channelKey: channel,
-		accountId,
-		name,
-		alwaysUseAccounts: true
+	...createPatchedAccountSetupAdapter({
+		channelKey: "whatsapp",
+		alwaysUseAccounts: true,
+		buildPatch: (input) => input.authDir ? { authDir: input.authDir } : {}
 	}),
-	applyAccountConfig: ({ cfg, accountId, input }) => {
-		const setupInput = input;
-		const next = migrateBaseNameToDefaultAccount({
-			cfg: applyAccountNameToChannelSection({
-				cfg,
-				channelKey: channel,
-				accountId,
-				name: setupInput.name,
-				alwaysUseAccounts: true
-			}),
-			channelKey: channel,
-			alwaysUseAccounts: true
-		});
-		const entry = {
-			...next.channels?.whatsapp?.accounts?.[accountId],
-			...setupInput.authDir ? { authDir: setupInput.authDir } : {},
-			enabled: true
-		};
-		return {
-			...next,
-			channels: {
-				...next.channels,
-				whatsapp: {
-					...next.channels?.whatsapp,
-					accounts: {
-						...next.channels?.whatsapp?.accounts,
-						[accountId]: entry
-					}
-				}
-			}
-		};
-	}
+	singleAccountKeysToMove: ["authDir"]
 };
 const whatsappSetupContract = defineChannelSetupContract({
 	fields: { authDir: {
@@ -152,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-BjvUbR6M.js");
+	return await import("./setup-surface-BkVcd769.js");
 }
 const whatsappSetupWizardProxy = createWhatsAppSetupWizardProxy(async () => (await loadWhatsAppSetupSurface()).whatsappSetupWizard);
 const whatsappConfigAdapter = createScopedChannelConfigAdapter({
@@ -291,13 +254,14 @@ function createWhatsAppPluginBase(params) {
 			isEnabled: (account) => account.enabled,
 			disabledReason: () => "disabled",
 			isConfigured: params.isConfigured,
+			isLinked: params.isLinked,
 			hasPersistedAuthState: ({ cfg }) => hasAnyWhatsAppAuth(cfg),
-			unconfiguredReason: () => "not linked",
+			unconfiguredReason: () => "not configured",
+			unlinkedReason: () => "not linked",
 			describeAccount: (account) => describeAccountSnapshot({
 				account,
 				configured: Boolean(account.authDir),
 				extra: {
-					linked: Boolean(account.authDir),
 					dmPolicy: account.dmPolicy,
 					allowFrom: account.allowFrom
 				}
@@ -340,4 +304,4 @@ function createWhatsAppPluginBase(params) {
 	};
 }
 //#endregion
-export { resolveWhatsAppGroupRequireMention as a, isWhatsAppAuthConfigured as c, whatsappSetupContract as i, loadWhatsAppChannelRuntime as l, whatsappSetupWizardProxy as n, resolveWhatsAppGroupToolPolicy as o, whatsappSetupAdapter as r, formatWhatsAppConfigAllowFromEntries as s, createWhatsAppPluginBase as t };
+export { resolveWhatsAppGroupRequireMention as a, loadWhatsAppChannelRuntime as c, whatsappSetupContract as i, readWhatsAppAccountLinkState as l, whatsappSetupWizardProxy as n, resolveWhatsAppGroupToolPolicy as o, whatsappSetupAdapter as r, formatWhatsAppConfigAllowFromEntries as s, createWhatsAppPluginBase as t };

package/node_modules/{p-queue → baileys/node_modules/p-queue}/dist/index.js

@@ -12,9 +12,13 @@ export default class PQueue extends EventEmitter {
     #rateLimitedInInterval = false;
     #rateLimitFlushScheduled = false;
     #interval;
+    /*
+    Timestamp when the current interval window ends. Kept accurate at every window transition: `#initializeIntervalIfNeeded` sets it when a window starts and `#onInterval` advances it as the recurring timer rolls into each new window. This is the source of truth for whether a task added after the queue goes idle belongs to a fresh window, so it must not go stale.
+    */
     #intervalEnd = 0;
-    #lastExecutionTime = 0;
+    // Recurring timer that drives windows while the queue is actively processing. Absent (`undefined`) once the queue goes idle.
     #intervalId;
+    // One-shot timer used while idle to resume at the next window boundary, since `#intervalId` is cleared when idle.
     #timeoutId;
     #strict;
     // Circular buffer implementation for better performance
@@ -175,26 +179,15 @@ export default class PQueue extends EventEmitter {
             }
             return false;
         }
-        // Fixed window mode (original logic)
+        // Fixed window mode. While the recurring timer runs it already governs the windows, so pausing is only decided here when the queue is idle (the timer is absent) and we rely on `#intervalEnd`.
         if (this.#intervalId === undefined) {
             const delay = this.#intervalEnd - now;
             if (delay < 0) {
-                // If the interval has expired while idle, check if we should enforce the interval
-                // from the last task execution. This ensures proper spacing between tasks even
-                // when the queue becomes empty and then new tasks are added.
-                if (this.#lastExecutionTime > 0) {
-                    const timeSinceLastExecution = now - this.#lastExecutionTime;
-                    if (timeSinceLastExecution < this.#interval) {
-                        // Not enough time has passed since the last task execution
-                        this.#createIntervalTimeout(this.#interval - timeSinceLastExecution);
-                        return true;
-                    }
-                }
-                // Enough time has passed or no previous execution, allow execution
-                this.#intervalCount = (this.#carryoverIntervalCount) ? this.#pending : 0;
+                // The interval expired while idle, so reset the count for the new window.
+                this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
             }
             else {
-                // Act as the interval is pending
+                // Still inside the previous window; wait out the remaining time before starting the next task.
                 this.#createIntervalTimeout(delay);
                 return true;
             }
@@ -249,11 +242,11 @@ export default class PQueue extends EventEmitter {
                     this.#consumeIntervalSlot(now);
                     this.#scheduleRateLimitUpdate();
                 }
-                this.emit('active');
-                job();
                 if (canInitializeInterval) {
                     this.#initializeIntervalIfNeeded();
                 }
+                this.emit('active');
+                job();
                 taskStarted = true;
             }
         }
@@ -275,8 +268,15 @@ export default class PQueue extends EventEmitter {
     #onInterval() {
         // Non-strict mode uses interval timers and intervalCount
         if (!this.#strict) {
-            if (this.#intervalCount === 0 && this.#pending === 0 && this.#intervalId) {
-                this.#clearIntervalTimer();
+            // Only touch the recurring interval timer here. When resumed via a timeout instead, `#intervalId` is undefined and `#initializeIntervalIfNeeded` sets `#intervalEnd` right after.
+            if (this.#intervalId !== undefined) {
+                if (this.#intervalCount === 0 && this.#pending === 0) {
+                    this.#clearIntervalTimer();
+                }
+                else {
+                    // The recurring timer fired, starting a new window. Keep the boundary accurate so tasks added after the queue later goes idle are scheduled against the correct window.
+                    this.#intervalEnd = Date.now() + this.#interval;
+                }
             }
             this.#intervalCount = this.#carryoverIntervalCount ? this.#pending : 0;
         }
@@ -381,7 +381,6 @@ export default class PQueue extends EventEmitter {
                         this.#runningTasks.delete(taskSymbol);
                         throw error;
                     }
-                    this.#lastExecutionTime = Date.now();
                     let operation = function_({ signal: options.signal });
                     if (options.timeout !== undefined) {
                         operation = pTimeout(Promise.resolve(operation), {

package/node_modules/{p-queue → baileys/node_modules/p-queue}/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "p-queue",
-	"version": "9.3.2",
+	"version": "9.3.3",
 	"description": "Promise queue with concurrency control",
 	"license": "MIT",
 	"repository": "sindresorhus/p-queue",