@openclaw/whatsapp 2026.5.22 → 2026.5.24-beta.1

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-D4UqEXqf.js";
+import { n as whatsAppActionRuntime, t as handleWhatsAppAction } from "./action-runtime-DGx8vCsS.js";
+import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-C9jEw6hx.js";
+import { r as setWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 import { n as getStatusCode, t as formatError } from "./session-errors-BAj9D2La.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-E_kMiuZP.js";
 import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.js";
 import { t as createWhatsAppLoginTool } from "./agent-tools-login-BDzvb3ee.js";
-import { n as setWhatsAppRuntime } from "./runtime-CboC4QhQ.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-GTQvJznL.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-BrKb0mwT.js";
 import { t as DEFAULT_WEB_MEDIA_BYTES } from "./constants-HU41RHGI.js";
-import { c as extractContactContext, d as extractMediaPlaceholder, p as extractText, u as extractLocationData } from "./send-api-CXPUXbUL.js";
-import { n as newConnectionId, r as waitForWaConnection, t as createWaSocket } from "./session-CPsgRMMa.js";
+import { c as extractContactContext, d as extractMediaPlaceholder, p as extractText, u as extractLocationData } from "./send-api-CC-vHBWG.js";
+import { n as newConnectionId, r as waitForWaConnection, t as createWaSocket } from "./session-CDgpDc0l.js";
 import { n as resolveWebAccountId, t as getActiveWebListener } from "./active-listener-B4SDebQ6.js";
-import { a as loadWebMediaRaw, c as monitorWebInbox, i as loadWebMedia, l as resetWebInboundDedupe, n as LocalMediaAccessError, o as optimizeImageToJpeg, r as getDefaultLocalRoots, s as optimizeImageToPng, t as monitorWebChannel } from "./monitor-ClhD-fQ6.js";
-import { t as loginWeb } from "./login-nJwaNuC-.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-BU1ydkuF.js";
+import { t as loginWeb } from "./login-BEkrpJbZ.js";
 import { HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN, stripHeartbeatToken } from "openclaw/plugin-sdk/reply-runtime";
 export { DEFAULT_WEB_MEDIA_BYTES, HEARTBEAT_PROMPT, HEARTBEAT_TOKEN, LocalMediaAccessError, SILENT_REPLY_TOKEN, WA_WEB_AUTH_DIR, WHATSAPP_AUTH_UNSTABLE_CODE, WhatsAppAuthUnstableError, createWaSocket, createWhatsAppLoginTool, extractContactContext, extractLocationData, extractMediaPlaceholder, extractText, formatError, formatWhatsAppWebAuthStatusState, getActiveWebListener, getDefaultLocalRoots, getStatusCode, getWebAuthAgeMs, handleWhatsAppAction, hasWebCredsSync, loadWebMedia, loadWebMediaRaw, logWebSelfId, loginWeb, logoutWeb, monitorWebChannel, monitorWebInbox, newConnectionId, optimizeImageToJpeg, optimizeImageToPng, pickWebChannel, readCredsJsonRaw, readWebAuthExistsBestEffort, readWebAuthExistsForDecision, readWebAuthSnapshot, readWebAuthSnapshotBestEffort, readWebAuthState, readWebSelfId, readWebSelfIdentity, readWebSelfIdentityForDecision, resetWebInboundDedupe, resolveDefaultWebAuthDir, resolveWebAccountId, resolveWebCredsBackupPath, resolveWebCredsPath, restoreCredsFromBackupIfNeeded, sendMessageWhatsApp, sendPollWhatsApp, sendReactionWhatsApp, sendTypingWhatsApp, setWhatsAppRuntime, startWebLoginWithQr, stripHeartbeatToken, waitForCredsSaveQueue, waitForCredsSaveQueueWithTimeout, waitForWaConnection, waitForWebLogin, webAuthExists, whatsAppActionRuntime, writeCredsJsonAtomically };

package/dist/runtime-setter-api.js

@@ -1,2 +1,2 @@
-import { n as setWhatsAppRuntime } from "./runtime-CboC4QhQ.js";
+import { r as setWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
 export { setWhatsAppRuntime };

package/dist/send-C9jEw6hx.js

@@ -0,0 +1,625 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { r as resolveDefaultWhatsAppAccountId } from "./account-ids-CB5SOWjc.js";
+import { a as resolveWhatsAppAccount, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BPYgj8Fv.js";
+import { c as normalizeWhatsAppTarget, n as isWhatsAppNewsletterJid } from "./normalize-target-bVWjgftN.js";
+import "./normalize-Bxwqo-bW.js";
+import { t as getOptionalWhatsAppRuntime } from "./runtime-BfAdAEYT.js";
+import { t as getRegisteredWhatsAppConnectionController } from "./connection-controller-registry-TSX_udJp.js";
+import { a as resolveWhatsAppOutboundMediaUrls, i as prepareWhatsAppOutboundMedia, n as normalizeWhatsAppPayloadText, s as resolveWhatsAppDocumentFileName } from "./outbound-media-contract-ioTkt8tn.js";
+import { d as markdownToWhatsApp, p as toWhatsappJid } from "./text-runtime-Dk37KYHj.js";
+import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
+import { generateSecureUuid } from "openclaw/plugin-sdk/core";
+import { redactIdentifier } from "openclaw/plugin-sdk/logging-core";
+import { convertMarkdownTables, resolveMarkdownTableMode } from "openclaw/plugin-sdk/markdown-table-runtime";
+import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { normalizePollInput } from "openclaw/plugin-sdk/poll-runtime";
+import { createSubsystemLogger, getChildLogger as getChildLogger$1 } from "openclaw/plugin-sdk/runtime-env";
+import { createResolvedApproverActionAuthAdapter, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
+import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
+//#region extensions/whatsapp/src/approval-auth.ts
+function normalizeWhatsAppApproverId(value) {
+	const normalized = normalizeWhatsAppTarget(String(value));
+	if (!normalized || normalized.endsWith("@g.us")) return;
+	return normalized;
+}
+function normalizeWhatsAppApproverEntry(value) {
+	return String(value).trim() === "*" ? "*" : normalizeWhatsAppApproverId(value);
+}
+function getWhatsAppApprovalApprovers(params) {
+	return resolveApprovalApprovers({
+		allowFrom: resolveWhatsAppAccount({
+			cfg: params.cfg,
+			accountId: params.accountId
+		}).allowFrom,
+		normalizeApprover: normalizeWhatsAppApproverEntry
+	});
+}
+const whatsappResolvedApproverAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "WhatsApp",
+	resolveApprovers: ({ cfg, accountId }) => getWhatsAppApprovalApprovers({
+		cfg,
+		accountId
+	}),
+	normalizeSenderId: (value) => normalizeWhatsAppApproverId(value)
+});
+const whatsappApprovalAuth = { authorizeActorAction({ cfg, accountId, senderId, approvalKind }) {
+	if (getWhatsAppApprovalApprovers({
+		cfg,
+		accountId
+	}).includes("*")) return { authorized: true };
+	return whatsappResolvedApproverAuth.authorizeActorAction({
+		cfg,
+		accountId,
+		senderId,
+		action: "approve",
+		approvalKind
+	});
+} };
+//#endregion
+//#region extensions/whatsapp/src/approval-reactions.ts
+const WHATSAPP_APPROVAL_REACTION_META = {
+	"allow-once": {
+		emoji: "👍",
+		label: "Allow Once"
+	},
+	deny: {
+		emoji: "👎",
+		label: "Deny"
+	}
+};
+const WHATSAPP_APPROVAL_REACTION_ORDER = ["allow-once", "deny"];
+const PERSISTENT_NAMESPACE = "whatsapp.approval-reactions";
+const PERSISTENT_MAX_ENTRIES = 1e3;
+const DEFAULT_REACTION_TARGET_TTL_MS = 1440 * 60 * 1e3;
+const whatsappApprovalReactionTargets = /* @__PURE__ */ new Map();
+let persistentStore;
+let persistentStoreDisabled = false;
+let resolverRuntimePromise;
+function loadApprovalResolver() {
+	resolverRuntimePromise ??= import("./approval-resolver-e1hAVRRy.js");
+	return resolverRuntimePromise;
+}
+function buildReactionTargetKey(params) {
+	const accountId = params.accountId.trim();
+	const remoteJid = params.remoteJid.trim();
+	const messageId = params.messageId.trim();
+	if (!accountId || !remoteJid || !messageId) return null;
+	return `${accountId}:${remoteJid}:${messageId}`;
+}
+function reportPersistentApprovalReactionError(error) {
+	try {
+		getOptionalWhatsAppRuntime()?.logging.getChildLogger({
+			plugin: "whatsapp",
+			feature: "approval-reaction-state"
+		}).warn("WhatsApp persistent approval reaction state failed", { error: String(error) });
+	} catch {}
+}
+function disablePersistentApprovalReactionStore(error) {
+	persistentStoreDisabled = true;
+	persistentStore = void 0;
+	reportPersistentApprovalReactionError(error);
+}
+function getPersistentApprovalReactionStore() {
+	if (persistentStoreDisabled) return;
+	if (persistentStore) return persistentStore;
+	const runtime = getOptionalWhatsAppRuntime();
+	if (!runtime) return;
+	try {
+		persistentStore = runtime.state.openKeyedStore({
+			namespace: PERSISTENT_NAMESPACE,
+			maxEntries: PERSISTENT_MAX_ENTRIES,
+			defaultTtlMs: DEFAULT_REACTION_TARGET_TTL_MS
+		});
+		return persistentStore;
+	} catch (error) {
+		disablePersistentApprovalReactionStore(error);
+		return;
+	}
+}
+function readPersistedTarget(value) {
+	const persisted = value;
+	if (persisted?.version !== 1 || !persisted.target || typeof persisted.target.approvalId !== "string" || !Array.isArray(persisted.target.allowedDecisions)) return null;
+	return persisted.target;
+}
+function rememberPersistentApprovalReactionTarget(params) {
+	const ttlMs = params.ttlMs == null ? DEFAULT_REACTION_TARGET_TTL_MS : Math.max(1, params.ttlMs);
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return;
+	store.register(params.key, {
+		version: 1,
+		target: params.target
+	}, { ttlMs }).catch(disablePersistentApprovalReactionStore);
+}
+function forgetPersistentApprovalReactionTarget(key) {
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return;
+	store.delete(key).catch(disablePersistentApprovalReactionStore);
+}
+async function lookupPersistentApprovalReactionTarget(key) {
+	const store = getPersistentApprovalReactionStore();
+	if (!store) return null;
+	try {
+		return readPersistedTarget(await store.lookup(key));
+	} catch (error) {
+		disablePersistentApprovalReactionStore(error);
+		return null;
+	}
+}
+function listWhatsAppApprovalReactionBindings(allowedDecisions) {
+	const allowed = new Set(allowedDecisions);
+	return WHATSAPP_APPROVAL_REACTION_ORDER.filter((decision) => allowed.has(decision)).map((decision) => ({
+		decision,
+		emoji: WHATSAPP_APPROVAL_REACTION_META[decision].emoji,
+		label: WHATSAPP_APPROVAL_REACTION_META[decision].label
+	}));
+}
+function buildWhatsAppApprovalReactionHint(allowedDecisions) {
+	const bindings = listWhatsAppApprovalReactionBindings(allowedDecisions);
+	if (bindings.length === 0) return null;
+	return `React with:\n\n${bindings.map((binding) => `${binding.emoji} ${binding.label}`).join("\n")}`;
+}
+function insertWhatsAppApprovalReactionHintNearHeader(params) {
+	const lines = params.text.split(/\r?\n/);
+	const idLineIndex = lines.findIndex((line) => /^ID:\s*\S+/.test(line.trim()));
+	if (idLineIndex >= 0) {
+		const before = lines.slice(0, idLineIndex + 1).join("\n");
+		const after = lines.slice(idLineIndex + 1).join("\n").replace(/^\n+/, "");
+		return after ? `${before}\n\n${params.hint}\n\n${after}` : `${before}\n\n${params.hint}`;
+	}
+	return `${params.hint}\n\n${params.text}`;
+}
+function addWhatsAppApprovalReactionHintToText(params) {
+	if (/(^|\n)React with:\s*(\n|$)/i.test(params.text)) return params.text;
+	const hint = buildWhatsAppApprovalReactionHint(params.allowedDecisions);
+	return hint ? insertWhatsAppApprovalReactionHintNearHeader({
+		text: params.text,
+		hint
+	}) : params.text;
+}
+function appendWhatsAppApprovalReactionHintForOutboundMessage(text) {
+	if (/(^|\n)React with:\s*(\n|$)/i.test(text)) return text;
+	const binding = extractWhatsAppApprovalPromptBinding(text);
+	if (!binding) return text;
+	return addWhatsAppApprovalReactionHintToText({
+		text,
+		allowedDecisions: binding.allowedDecisions
+	});
+}
+function resolveWhatsAppApprovalReactionDecision(reactionKey, allowedDecisions) {
+	const normalizedReaction = reactionKey.trim();
+	if (!normalizedReaction) return null;
+	const allowed = new Set(allowedDecisions);
+	for (const decision of WHATSAPP_APPROVAL_REACTION_ORDER) {
+		if (!allowed.has(decision)) continue;
+		if (WHATSAPP_APPROVAL_REACTION_META[decision].emoji === normalizedReaction) return decision;
+	}
+	return null;
+}
+function normalizeApprovalDecision(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "always") return "allow-always";
+	if (normalized === "allow-once" || normalized === "allow-always" || normalized === "deny") return normalized;
+	return null;
+}
+function extractWhatsAppApprovalPromptBinding(text) {
+	const allowedDecisions = [];
+	let approvalId = "";
+	for (const line of text.split(/\r?\n/)) {
+		const match = line.match(/\/approve(?:@[^\s]+)?\s+([A-Za-z0-9][A-Za-z0-9._:-]*)\s+(.+)$/i);
+		if (!match) continue;
+		if (approvalId && match[1] !== approvalId) continue;
+		approvalId ||= match[1];
+		const decisions = match[2].split(/[\s|,]+/);
+		for (const decisionText of decisions) {
+			const decision = normalizeApprovalDecision(decisionText);
+			if (decision && !allowedDecisions.includes(decision)) allowedDecisions.push(decision);
+		}
+	}
+	return approvalId && allowedDecisions.length > 0 ? {
+		approvalId,
+		allowedDecisions
+	} : null;
+}
+function registerWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	const approvalId = params.approvalId.trim();
+	const allowedDecisions = listWhatsAppApprovalReactionBindings(params.allowedDecisions).map((binding) => binding.decision);
+	if (!key || !approvalId || allowedDecisions.length === 0) return null;
+	const target = {
+		approvalId,
+		allowedDecisions
+	};
+	whatsappApprovalReactionTargets.set(key, target);
+	rememberPersistentApprovalReactionTarget({
+		key,
+		target,
+		ttlMs: params.ttlMs
+	});
+	return target;
+}
+function registerWhatsAppApprovalReactionTargetForOutboundMessage(params) {
+	const binding = extractWhatsAppApprovalPromptBinding(params.text);
+	if (!binding) return false;
+	return Boolean(registerWhatsAppApprovalReactionTarget({
+		accountId: params.accountId,
+		remoteJid: params.remoteJid,
+		messageId: params.messageId,
+		approvalId: binding.approvalId,
+		allowedDecisions: binding.allowedDecisions,
+		ttlMs: params.ttlMs
+	}));
+}
+function unregisterWhatsAppApprovalReactionTarget(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return;
+	whatsappApprovalReactionTargets.delete(key);
+	forgetPersistentApprovalReactionTarget(key);
+}
+function resolveTarget(params) {
+	const target = params.target;
+	if (!target) return null;
+	const decision = resolveWhatsAppApprovalReactionDecision(params.reactionKey, target.allowedDecisions);
+	return decision ? {
+		approvalId: target.approvalId,
+		decision
+	} : null;
+}
+async function resolveWhatsAppApprovalReactionTargetWithPersistence(params) {
+	const key = buildReactionTargetKey(params);
+	if (!key) return null;
+	const inMemory = resolveTarget({
+		target: whatsappApprovalReactionTargets.get(key),
+		reactionKey: params.reactionKey
+	});
+	if (inMemory) return inMemory;
+	return resolveTarget({
+		target: await lookupPersistentApprovalReactionTarget(key),
+		reactionKey: params.reactionKey
+	});
+}
+function readWhatsAppApprovalReactionEvent(params) {
+	const msg = params.msg;
+	const reaction = msg.message?.reactionMessage;
+	const reactionKey = reaction?.text?.trim() ?? "";
+	const messageId = reaction?.key?.id?.trim() ?? "";
+	const remoteJid = (reaction?.key?.remoteJid ?? msg.key?.remoteJid ?? "").trim();
+	const actorJid = msg.key?.participant?.trim() || (msg.key?.fromMe ? params.selfLid?.trim() ?? params.selfJid?.trim() ?? "" : msg.key?.remoteJid?.trim() ?? "");
+	if (!reactionKey || !messageId || !remoteJid || !actorJid) return null;
+	return {
+		remoteJid,
+		messageId,
+		actorJid,
+		reactionKey
+	};
+}
+async function maybeResolveWhatsAppApprovalReaction(params) {
+	const event = readWhatsAppApprovalReactionEvent({
+		msg: params.msg,
+		selfJid: params.selfJid,
+		selfLid: params.selfLid
+	});
+	if (!event) return false;
+	const target = await resolveWhatsAppApprovalReactionTargetWithPersistence({
+		accountId: params.accountId,
+		remoteJid: event.remoteJid,
+		messageId: event.messageId,
+		reactionKey: event.reactionKey
+	});
+	if (!target) return false;
+	const actorId = await params.resolveInboundJid(event.actorJid);
+	if (!actorId) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction ignored for ${target.approvalId}; missing actor identity`);
+		return true;
+	}
+	const approvalKind = target.approvalId.startsWith("plugin:") ? "plugin" : "exec";
+	if (getWhatsAppApprovalApprovers({
+		cfg: params.cfg,
+		accountId: params.accountId
+	}).length === 0) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId}; reactions require explicit approvers`);
+		return true;
+	}
+	if (!whatsappApprovalAuth.authorizeActorAction({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		senderId: actorId,
+		action: "approve",
+		approvalKind
+	}).authorized) {
+		params.logVerboseMessage?.(`whatsapp: approval reaction denied id=${target.approvalId} sender=${actorId}`);
+		return true;
+	}
+	const { isApprovalNotFoundError, resolveWhatsAppApproval } = await loadApprovalResolver();
+	try {
+		await resolveWhatsAppApproval({
+			cfg: params.cfg,
+			approvalId: target.approvalId,
+			decision: target.decision,
+			senderId: actorId,
+			gatewayUrl: params.gatewayUrl
+		});
+		params.logVerboseMessage?.(`whatsapp: approval reaction resolved id=${target.approvalId} sender=${actorId} decision=${target.decision}`);
+		return true;
+	} catch (error) {
+		if (isApprovalNotFoundError(error)) {
+			unregisterWhatsAppApprovalReactionTarget({
+				accountId: params.accountId,
+				remoteJid: event.remoteJid,
+				messageId: event.messageId
+			});
+			params.logVerboseMessage?.(`whatsapp: approval reaction ignored for expired approval id=${target.approvalId} sender=${actorId}`);
+			return true;
+		}
+		params.logVerboseMessage?.(`whatsapp: approval reaction failed id=${target.approvalId} sender=${actorId}: ${String(error)}`);
+		return true;
+	}
+}
+//#endregion
+//#region extensions/whatsapp/src/outbound-media.runtime.ts
+async function loadOutboundMediaFromUrl(mediaUrl, options = {}) {
+	const readFile = options.mediaAccess?.readFile ?? options.mediaReadFile;
+	const localRoots = options.mediaAccess?.localRoots?.length && options.mediaAccess.localRoots.length > 0 ? options.mediaAccess.localRoots : options.mediaLocalRoots && options.mediaLocalRoots.length > 0 ? options.mediaLocalRoots : void 0;
+	const sharedOptions = {
+		...options.maxBytes !== void 0 ? { maxBytes: options.maxBytes } : {},
+		...options.optimizeImages !== void 0 ? { optimizeImages: options.optimizeImages } : {}
+	};
+	return await loadWebMedia(mediaUrl, readFile ? {
+		...sharedOptions,
+		localRoots: "any",
+		readFile,
+		hostReadCapability: true
+	} : {
+		...sharedOptions,
+		...localRoots ? { localRoots } : {}
+	});
+}
+//#endregion
+//#region extensions/whatsapp/src/send.ts
+var send_exports = /* @__PURE__ */ __exportAll({
+	sendMessageWhatsApp: () => sendMessageWhatsApp,
+	sendPollWhatsApp: () => sendPollWhatsApp,
+	sendReactionWhatsApp: () => sendReactionWhatsApp,
+	sendTypingWhatsApp: () => sendTypingWhatsApp
+});
+const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+function supportsForcedDocumentDelivery(kind) {
+	return kind === "image" || kind === "video";
+}
+function resolveOutboundWhatsAppAccountId(params) {
+	const explicitAccountId = params.accountId?.trim();
+	if (explicitAccountId) return explicitAccountId;
+	return resolveDefaultWhatsAppAccountId(params.cfg);
+}
+function requireOutboundActiveWebListener(params) {
+	const resolvedAccountId = resolveOutboundWhatsAppAccountId(params) ?? resolveDefaultWhatsAppAccountId(params.cfg);
+	const listener = getRegisteredWhatsAppConnectionController(resolvedAccountId)?.getActiveListener() ?? null;
+	if (!listener) throw new Error(`No active WhatsApp Web listener (account: ${resolvedAccountId}). Start the gateway, then link WhatsApp with: ${formatCliCommand(`openclaw channels login --channel whatsapp --account ${resolvedAccountId}`)}.`);
+	return {
+		accountId: resolvedAccountId,
+		listener
+	};
+}
+function resolveActualSentRemoteJid(result, fallbackJid) {
+	if (!result || typeof result !== "object") return fallbackJid;
+	const rawKeys = result.keys;
+	const keys = Array.isArray(rawKeys) ? rawKeys : [];
+	for (const key of keys) if (typeof key?.remoteJid === "string" && key.remoteJid.trim()) return key.remoteJid.trim();
+	return fallbackJid;
+}
+async function sendMessageWhatsApp(to, body, options) {
+	let text = options.preserveLeadingWhitespace ? body : normalizeWhatsAppPayloadText(body);
+	const jid = toWhatsappJid(to);
+	const mediaUrls = resolveWhatsAppOutboundMediaUrls(options);
+	const mediaPayload = options.mediaPayload;
+	const primaryMediaUrl = mediaUrls[0] ?? mediaPayload?.fileName;
+	const hasMedia = Boolean(mediaPayload || primaryMediaUrl);
+	if (!text && !hasMedia) return {
+		messageId: "",
+		toJid: jid
+	};
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const cfg = requireRuntimeConfig(options.cfg, "WhatsApp send");
+	const { listener: active, accountId: resolvedAccountId } = requireOutboundActiveWebListener({
+		cfg,
+		accountId: options.accountId
+	});
+	const account = resolveWhatsAppAccount({
+		cfg,
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	const tableMode = resolveMarkdownTableMode({
+		cfg,
+		channel: "whatsapp",
+		accountId: resolvedAccountId ?? options.accountId
+	});
+	text = convertMarkdownTables(text ?? "", tableMode);
+	text = markdownToWhatsApp(text);
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger$1({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const redactedJid = redactIdentifier(jid);
+		let mediaBuffer;
+		let mediaType;
+		let documentFileName;
+		let visibleTextAfterVoice;
+		let forceDocumentDelivery = false;
+		if (mediaPayload) {
+			const media = await prepareWhatsAppOutboundMedia(mediaPayload, primaryMediaUrl);
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.mimetype;
+			forceDocumentDelivery = Boolean(options.forceDocument && supportsForcedDocumentDelivery(media.kind));
+			if (media.kind === "audio" && caption) {
+				visibleTextAfterVoice = caption;
+				text = "";
+			} else if (media.kind === "document") {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			} else text = caption ?? "";
+			if (forceDocumentDelivery) documentFileName ??= resolveWhatsAppDocumentFileName({
+				fileName: media.fileName,
+				mimetype: media.mimetype
+			});
+		} else if (primaryMediaUrl) {
+			const media = await prepareWhatsAppOutboundMedia(await loadOutboundMediaFromUrl(primaryMediaUrl, {
+				maxBytes: resolveWhatsAppMediaMaxBytes(account),
+				optimizeImages: options.forceDocument ? false : void 0,
+				mediaAccess: options.mediaAccess,
+				mediaLocalRoots: options.mediaLocalRoots,
+				mediaReadFile: options.mediaReadFile
+			}), primaryMediaUrl);
+			const caption = text || void 0;
+			mediaBuffer = media.buffer;
+			mediaType = media.mimetype;
+			forceDocumentDelivery = Boolean(options.forceDocument && supportsForcedDocumentDelivery(media.kind));
+			if (media.kind === "audio" && caption) {
+				visibleTextAfterVoice = caption;
+				text = "";
+			} else if (media.kind === "document") {
+				text = caption ?? "";
+				documentFileName = media.fileName;
+			} else text = caption ?? "";
+			if (forceDocumentDelivery) documentFileName ??= resolveWhatsAppDocumentFileName({
+				fileName: media.fileName,
+				mimetype: media.mimetype
+			});
+		}
+		outboundLog.info(`Sending message -> ${redactedJid}${hasMedia ? " (media)" : ""}`);
+		logger.info({
+			jid: redactedJid,
+			hasMedia
+		}, "sending message");
+		if (!isWhatsAppNewsletterJid(jid)) await active.sendComposingTo(to);
+		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
+		const sendOptions = options.gifPlayback || forceDocumentDelivery || accountId || documentFileName || options.quotedMessageKey ? {
+			...options.gifPlayback ? { gifPlayback: true } : {},
+			...forceDocumentDelivery ? { asDocument: true } : {},
+			...documentFileName ? { fileName: documentFileName } : {},
+			...options.quotedMessageKey ? { quotedMessageKey: options.quotedMessageKey } : {},
+			accountId
+		} : void 0;
+		const outboundText = text ? appendWhatsAppApprovalReactionHintForOutboundMessage(text) : text;
+		const result = sendOptions ? await active.sendMessage(to, outboundText, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, outboundText, mediaBuffer, mediaType);
+		if (visibleTextAfterVoice) if (sendOptions) await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0, sendOptions);
+		else await active.sendMessage(to, visibleTextAfterVoice, void 0, void 0);
+		const messageId = result?.messageId ?? "unknown";
+		const sentRemoteJid = resolveActualSentRemoteJid(result, jid);
+		if (messageId && messageId !== "unknown" && outboundText) registerWhatsAppApprovalReactionTargetForOutboundMessage({
+			accountId: resolvedAccountId,
+			remoteJid: sentRemoteJid,
+			messageId,
+			text: outboundText
+		});
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent message ${messageId} -> ${redactedJid}${hasMedia ? " (media)" : ""} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent message");
+		return {
+			messageId,
+			toJid: sentRemoteJid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo,
+			hasMedia
+		}, "failed to send via web session");
+		throw err;
+	}
+}
+async function sendTypingWhatsApp(to, options) {
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp typing send"),
+		accountId: options.accountId
+	});
+	if (!isWhatsAppNewsletterJid(toWhatsappJid(to))) await active.sendComposingTo(to);
+}
+async function sendReactionWhatsApp(chatJid, messageId, emoji, options) {
+	const correlationId = generateSecureUuid();
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp reaction"),
+		accountId: options.accountId
+	});
+	const redactedChatJid = redactIdentifier(chatJid);
+	const logger = getChildLogger$1({
+		module: "web-outbound",
+		correlationId,
+		chatJid: redactedChatJid,
+		messageId
+	});
+	try {
+		const redactedJid = redactIdentifier(toWhatsappJid(chatJid));
+		outboundLog.info(`Sending reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sending reaction");
+		await active.sendReaction(chatJid, messageId, emoji, options.fromMe ?? false, options.participant);
+		outboundLog.info(`Sent reaction "${emoji}" -> message ${messageId}`);
+		logger.info({
+			chatJid: redactedJid,
+			messageId,
+			emoji
+		}, "sent reaction");
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			chatJid: redactedChatJid,
+			messageId,
+			emoji
+		}, "failed to send reaction via web session");
+		throw err;
+	}
+}
+async function sendPollWhatsApp(to, poll, options) {
+	const correlationId = generateSecureUuid();
+	const startedAt = Date.now();
+	const { listener: active } = requireOutboundActiveWebListener({
+		cfg: requireRuntimeConfig(options.cfg, "WhatsApp poll"),
+		accountId: options.accountId
+	});
+	const redactedTo = redactIdentifier(to);
+	const logger = getChildLogger$1({
+		module: "web-outbound",
+		correlationId,
+		to: redactedTo
+	});
+	try {
+		const jid = toWhatsappJid(to);
+		const redactedJid = redactIdentifier(jid);
+		const normalized = normalizePollInput(poll, { maxOptions: 12 });
+		outboundLog.info(`Sending poll -> ${redactedJid}`);
+		logger.info({
+			jid: redactedJid,
+			optionCount: normalized.options.length,
+			maxSelections: normalized.maxSelections
+		}, "sending poll");
+		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		const durationMs = Date.now() - startedAt;
+		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);
+		logger.info({
+			jid: redactedJid,
+			messageId
+		}, "sent poll");
+		return {
+			messageId,
+			toJid: jid
+		};
+	} catch (err) {
+		logger.error({
+			err: String(err),
+			to: redactedTo
+		}, "failed to send poll via web session");
+		throw err;
+	}
+}
+//#endregion
+export { send_exports as a, maybeResolveWhatsAppApprovalReaction as c, getWhatsAppApprovalApprovers as d, whatsappApprovalAuth as f, sendTypingWhatsApp as i, registerWhatsAppApprovalReactionTarget as l, sendPollWhatsApp as n, addWhatsAppApprovalReactionHintToText as o, sendReactionWhatsApp as r, buildWhatsAppApprovalReactionHint as s, sendMessageWhatsApp as t, unregisterWhatsAppApprovalReactionTarget as u };

package/dist/{send-api-CXPUXbUL.js → send-api-CC-vHBWG.js}

@@ -1,6 +1,6 @@
 import { n as isWhatsAppNewsletterJid } from "./normalize-target-bVWjgftN.js";
-import { s as resolveWhatsAppDocumentFileName } from "./outbound-media-contract-ioTkt8tn.js";
 import "./normalize-Bxwqo-bW.js";
+import { s as resolveWhatsAppDocumentFileName } from "./outbound-media-contract-ioTkt8tn.js";
 import { m as toWhatsappJidWithLid, p as toWhatsappJid, u as jidToE164 } from "./text-runtime-Dk37KYHj.js";
 import { t as buildQuotedMessageOptions } from "./quoted-message-CveINB35.js";
 import { c as resolveComparableIdentity } from "./identity-xoLLdqEv.js";
@@ -691,7 +691,7 @@ function createWebSendApi(params) {
 			return normalizeWhatsAppSendResult(result, "poll");
 		},
 		sendReaction: async (chatJid, messageId, emoji, fromMe, participant) => {
-			const jid = toWhatsappJid(chatJid);
+			const jid = resolveOutboundJid(chatJid);
 			return normalizeWhatsAppSendResult(await params.sock.sendMessage(jid, { react: {
 				text: emoji,
 				key: {