@openclaw/whatsapp 2026.7.2-beta.7 → 2026.8.1-beta.3

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

@@ -1,43 +1,26 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
-import { a as resolveWhatsAppAccount } from "./accounts-CSqLvCY5.js";
-import { questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
+import { a as resolveWhatsAppAccount } from "./accounts-BX2fZUyR.js";
+import { createQuestionReactionTargetStore, questionGatewayRuntime } from "openclaw/plugin-sdk/question-gateway-runtime";
 //#region extensions/whatsapp/src/question-reactions.ts
 var question_reactions_exports = /* @__PURE__ */ __exportAll({
-	clearWhatsAppQuestionReactionTargetsForTest: () => clearWhatsAppQuestionReactionTargetsForTest,
 	maybeResolveWhatsAppQuestionReaction: () => maybeResolveWhatsAppQuestionReaction,
 	registerWhatsAppQuestionReactionTargetForDeliveredPayload: () => registerWhatsAppQuestionReactionTargetForDeliveredPayload
 });
-const TARGET_TTL_MS = 1440 * 60 * 1e3;
-const targets = /* @__PURE__ */ new Map();
-function storeTarget(key, binding) {
-	const existing = targets.get(key);
-	if (existing) clearTimeout(existing.cleanupTimer);
-	const target = {
-		...binding,
-		terminal: false,
-		expiresAtMs: Date.now() + TARGET_TTL_MS,
-		cleanupTimer: setTimeout(() => {
-			if (targets.get(key) === target) targets.delete(key);
-		}, TARGET_TTL_MS)
-	};
-	target.cleanupTimer.unref?.();
-	targets.set(key, target);
-	questionGatewayRuntime.registerChannelDelivery({
-		questionId: binding.questionId,
-		deliveryId: `whatsapp-reaction:${key}`,
-		finalize: () => {
-			target.terminal = true;
-		}
-	});
-}
-function buildKey(accountId, remoteJid, messageId) {
+function buildKey(identity) {
 	const parts = [
-		accountId,
-		remoteJid,
-		messageId
+		identity.accountId,
+		identity.remoteJid,
+		identity.messageId
 	].map((part) => part.trim());
 	return parts.every(Boolean) ? parts.join(":") : void 0;
 }
+const questionReactionTargets = createQuestionReactionTargetStore({
+	channel: "whatsapp",
+	channelDisplayName: "WhatsApp",
+	buildKey,
+	registerChannelDelivery: questionGatewayRuntime.registerChannelDelivery,
+	resolveReaction: questionGatewayRuntime.resolveReaction
+});
 function addCandidate(values, value) {
 	const normalized = value?.trim();
 	if (normalized && !values.includes(normalized)) values.push(normalized);
@@ -73,12 +56,10 @@ function registerWhatsAppQuestionReactionTargetForDeliveredPayload(params) {
 		accountId: params.target.accountId
 	}).accountId;
 	let registered = false;
-	for (const identity of listDeliveredIdentities(params.results)) {
-		const key = buildKey(accountId, identity.remoteJid, identity.messageId);
-		if (!key) continue;
-		storeTarget(key, binding);
-		registered = true;
-	}
+	for (const identity of listDeliveredIdentities(params.results)) registered = questionReactionTargets.register(binding, {
+		accountId,
+		...identity
+	}) || registered;
 	return registered;
 }
 async function maybeResolveWhatsAppQuestionReaction(params) {
@@ -95,48 +76,18 @@ async function maybeResolveWhatsAppQuestionReaction(params) {
 		addCandidate(candidates, remoteJid);
 		for (const mapped of await params.resolveReactionTargetJids?.(remoteJid) ?? []) addCandidate(candidates, mapped);
 	}
-	let matched;
-	for (const remoteJid of candidates) {
-		const key = buildKey(params.accountId, remoteJid, messageId);
-		const target = key ? targets.get(key) : void 0;
-		if (key && target) {
-			matched = {
-				key,
-				target
-			};
-			break;
-		}
-	}
-	if (!matched) return false;
-	if (matched.target.expiresAtMs <= Date.now() || matched.target.terminal) {
-		matched.target.terminal = true;
-		params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
-		return true;
-	}
-	const optionValue = matched.target.optionValues[optionIndex];
-	if (!optionValue) {
-		params.logDebug?.(`whatsapp: out-of-range question reaction ignored id=${matched.target.questionId}`);
-		return true;
-	}
-	try {
-		const result = await questionGatewayRuntime.resolveReaction({
-			cfg: params.cfg,
-			questionId: matched.target.questionId,
-			optionValue,
-			senderId: params.senderId,
-			gatewayUrl: params.gatewayUrl,
-			clientDisplayName: `WhatsApp question (${params.senderId})`
-		});
-		matched.target.terminal = result?.status === "answered" || result?.status === "already-terminal";
-		if (result?.status === "already-terminal") params.logDebug?.(`whatsapp: stale question reaction ignored id=${matched.target.questionId}`);
-	} catch (error) {
-		params.logDebug?.(`whatsapp: question reaction failed id=${matched.target.questionId}: ${String(error)}`);
-	}
-	return true;
-}
-function clearWhatsAppQuestionReactionTargetsForTest() {
-	for (const target of targets.values()) clearTimeout(target.cleanupTimer);
-	targets.clear();
+	return await questionReactionTargets.resolve({
+		identities: candidates.map((remoteJid) => ({
+			accountId: params.accountId,
+			remoteJid,
+			messageId
+		})),
+		optionIndex,
+		cfg: params.cfg,
+		senderId: params.senderId,
+		gatewayUrl: params.gatewayUrl,
+		logDebug: params.logDebug
+	});
 }
 //#endregion
 export { question_reactions_exports as n, maybeResolveWhatsAppQuestionReaction as t };

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-BzfDFPbH.js";
-import { i as sendTypingWhatsApp, n as sendPollWhatsApp, r as sendReactionWhatsApp, t as sendMessageWhatsApp } from "./send-D37ddk22.js";
+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 { a as setWhatsAppRuntime } from "./runtime-BLlToOi6.js";
 import { startWebLoginWithQr, waitForWebLogin } from "./login-qr-runtime.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 createWhatsAppLoginTool } from "./agent-tools-login-BjRpD-JQ.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-DridEuzz.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 { 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 { 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 { 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/runtime-group-policy-DeSRFXEV.js

@@ -0,0 +1,11 @@
+import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
+//#region extensions/whatsapp/src/runtime-group-policy.ts
+function resolveWhatsAppRuntimeGroupPolicy(params) {
+	return resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy
+	});
+}
+//#endregion
+export { resolveWhatsAppRuntimeGroupPolicy as t };

package/dist/{send-D37ddk22.js → send-CwvTU4RI.js}

@@ -1,4 +1,4 @@
-import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-CSqLvCY5.js";
+import { a as resolveWhatsAppAccount, c as resolveMergedWhatsAppAccountConfig, s as resolveWhatsAppMediaMaxBytes } from "./accounts-BX2fZUyR.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";
@@ -6,7 +6,7 @@ import "./normalize-C7Hkc_vE.js";
 import { a as markdownToWhatsAppChunks, c as toWhatsappJid } from "./targets-runtime-TMk0lGuy.js";
 import { a as stripToolCallXmlTags, i as sanitizeAssistantVisibleTextWithProfile, r as sanitizeAssistantVisibleText } from "./text-runtime-CaKLhowd.js";
 import path from "node:path";
-import { normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { normalizeStringEntries, normalizeUniqueStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveReactionLevel } from "openclaw/plugin-sdk/status-helpers";
 import { formatCliCommand } from "openclaw/plugin-sdk/cli-runtime";
 import { generateSecureUuid } from "openclaw/plugin-sdk/core";
@@ -17,9 +17,12 @@ import { loadOutboundMediaFromUrl } from "openclaw/plugin-sdk/outbound-media";
 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 { createSubsystemLogger as createSubsystemLogger$1, getChildLogger as getChildLogger$1 } from "openclaw/plugin-sdk/runtime-env";
 import { extensionForMime, mediaKindFromMime, mimeTypeFromFilePath, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
-import { sanitizeForPlainText } from "openclaw/plugin-sdk/channel-outbound";
+import { AsyncLocalStorage } from "node:async_hooks";
+import { recordChannelActivity } from "openclaw/plugin-sdk/channel-activity-runtime";
+import { createChannelPartialDeliveryError, isChannelPartialDeliveryError } from "openclaw/plugin-sdk/channel-inbound";
+import { createMessageReceiptFromOutboundResults, listMessageReceiptPlatformIds, 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";
 //#region extensions/whatsapp/src/reaction-level.ts
@@ -54,6 +57,245 @@ function stripAsciiControlCharacters(value) {
 	return stripped;
 }
 //#endregion
+//#region extensions/whatsapp/src/inbound/send-result.ts
+const activityAccountedWhatsAppSendResults = /* @__PURE__ */ new WeakSet();
+const logicalWhatsAppDeliveryActivity = new AsyncLocalStorage();
+/** Keep all separately produced platform sends inside one logical reply accounting scope. */
+async function withWhatsAppLogicalDeliveryActivity(run) {
+	if (logicalWhatsAppDeliveryActivity.getStore()) return await run();
+	return await logicalWhatsAppDeliveryActivity.run({ accountedAccountIds: /* @__PURE__ */ new Set() }, run);
+}
+function resolveWhatsAppReceiptKind(kind) {
+	if (kind === "media" || kind === "text") return kind;
+	return "unknown";
+}
+function toReceiptSourceResult(key) {
+	return {
+		channel: "whatsapp",
+		messageId: key.id,
+		...key.remoteJid ? { toJid: key.remoteJid } : {},
+		meta: {
+			fromMe: key.fromMe,
+			participant: key.participant
+		}
+	};
+}
+function createWhatsAppSendReceipt(kind, keys) {
+	return createMessageReceiptFromOutboundResults({
+		kind: resolveWhatsAppReceiptKind(kind),
+		results: keys.map(toReceiptSourceResult)
+	});
+}
+function mergeWhatsAppReceiptSourceMetadata(sources) {
+	const defined = sources.filter((source) => Boolean(source));
+	const preferred = defined[0];
+	if (!preferred) return;
+	const merged = /* @__PURE__ */ new Map();
+	const meta = /* @__PURE__ */ new Map();
+	for (const source of defined.toReversed()) {
+		for (const [key, value] of Object.entries(source)) if (key !== "meta" && value !== void 0) merged.set(key, value);
+		for (const [key, value] of Object.entries(source.meta ?? {})) if (value !== void 0) meta.set(key, value);
+	}
+	const mergedSource = Object.assign({}, preferred, Object.fromEntries(merged));
+	if (meta.size > 0) mergedSource.meta = Object.fromEntries(meta);
+	else delete mergedSource.meta;
+	return mergedSource;
+}
+function enrichWhatsAppDeliveryReceipt(params) {
+	const seenPartIds = /* @__PURE__ */ new Set();
+	const parts = params.receipt.parts.flatMap((part) => {
+		if (seenPartIds.has(part.platformMessageId)) return [];
+		seenPartIds.add(part.platformMessageId);
+		const matchingParts = params.sources.flatMap((source) => source.parts.filter((candidate) => candidate.platformMessageId === part.platformMessageId));
+		const matchingRawSources = params.sources.flatMap((source) => source.raw?.filter((raw) => raw.messageId === part.platformMessageId) ?? []);
+		const raw = mergeWhatsAppReceiptSourceMetadata([
+			part.raw,
+			...matchingParts.map((candidate) => candidate.raw),
+			...matchingRawSources
+		]);
+		const threadId = part.threadId ?? matchingParts.find((candidate) => candidate.threadId)?.threadId;
+		const replyToId = part.replyToId ?? matchingParts.find((candidate) => candidate.replyToId)?.replyToId;
+		return [{
+			...part,
+			...threadId ? { threadId } : {},
+			...replyToId ? { replyToId } : {},
+			...raw ? { raw } : {}
+		}];
+	});
+	const threadId = params.receipt.threadId ?? params.sources.find((source) => source.threadId)?.threadId;
+	const replyToId = params.receipt.replyToId ?? params.sources.find((source) => source.replyToId)?.replyToId;
+	const editToken = params.receipt.editToken ?? params.sources.find((source) => source.editToken)?.editToken;
+	const deleteToken = params.receipt.deleteToken ?? params.sources.find((source) => source.deleteToken)?.deleteToken;
+	return {
+		...params.receipt,
+		parts,
+		raw: parts.map((part) => part.raw ?? {
+			channel: "whatsapp",
+			messageId: part.platformMessageId
+		}),
+		...threadId ? { threadId } : {},
+		...replyToId ? { replyToId } : {},
+		...editToken ? { editToken } : {},
+		...deleteToken ? { deleteToken } : {}
+	};
+}
+function normalizeKey(key) {
+	const id = typeof key?.id === "string" ? key.id.trim() : "";
+	if (!id) return;
+	return {
+		id,
+		remoteJid: key?.remoteJid,
+		fromMe: key?.fromMe,
+		participant: key?.participant
+	};
+}
+function createWhatsAppProviderNotAcceptedError(kind) {
+	const cause = /* @__PURE__ */ new Error("Baileys returned no accepted message key.");
+	return new PlatformMessageNotDispatchedError(`WhatsApp ${kind} send was not accepted by the provider: ${cause.message}`, { cause });
+}
+function normalizeWhatsAppSendResult(result, kind) {
+	const key = normalizeKey(result?.key);
+	if (!key) throw createWhatsAppProviderNotAcceptedError(kind);
+	return {
+		kind,
+		messageId: key.id,
+		receipt: createWhatsAppSendReceipt(kind, [key]),
+		keys: [key],
+		providerAccepted: true
+	};
+}
+/** Refuse synthetic ids from listener boundaries before callers create durable receipts. */
+function requireWhatsAppAcceptedSendResult(result) {
+	if (result.providerAccepted && result.messageId !== "unknown" && result.keys.some((key) => key.id === result.messageId) && listWhatsAppSendResultMessageIds(result).includes(result.messageId)) return result;
+	throw createWhatsAppProviderNotAcceptedError(result.kind);
+}
+/** Persist accepted provider facts before account bookkeeping or later platform sends can fail. */
+function rememberWhatsAppAcceptedSend(params) {
+	const accepted = requireWhatsAppAcceptedSendResult(params.result);
+	params.results.push(accepted);
+	if (params.results.length === 1) {
+		const deliveryActivity = logicalWhatsAppDeliveryActivity.getStore();
+		const alreadyAccounted = activityAccountedWhatsAppSendResults.has(accepted) || Boolean(deliveryActivity?.accountedAccountIds.has(params.accountId));
+		activityAccountedWhatsAppSendResults.add(accepted);
+		if (!alreadyAccounted) {
+			deliveryActivity?.accountedAccountIds.add(params.accountId);
+			recordChannelActivity({
+				channel: "whatsapp",
+				accountId: params.accountId,
+				direction: "outbound"
+			});
+		}
+	}
+	return accepted;
+}
+/** Nested owners already attempted activity accounting before exposing accepted delivery. */
+function rememberWhatsAppPartialSend(params) {
+	if (!isChannelPartialDeliveryError(params.error)) return false;
+	const delivery = params.error.deliveryResult;
+	const messageIds = uniqueStrings([...delivery.receipt ? listMessageReceiptPlatformIds(delivery.receipt) : [], ...normalizeStringEntries(delivery.messageIds ?? [])]).filter((messageId) => messageId !== "unknown");
+	const existingIds = new Set(params.results.flatMap(listWhatsAppSendResultMessageIds));
+	const acceptedIds = messageIds.filter((messageId) => !existingIds.has(messageId));
+	const messageId = acceptedIds[0];
+	if (!messageId) return false;
+	const receiptSources = [];
+	if (delivery.receipt) receiptSources.push({
+		channel: "whatsapp",
+		messageId,
+		receipt: delivery.receipt
+	});
+	const receiptIds = new Set(delivery.receipt ? listMessageReceiptPlatformIds(delivery.receipt) : []);
+	for (const acceptedId of acceptedIds) if (!receiptIds.has(acceptedId)) receiptSources.push({
+		channel: "whatsapp",
+		messageId: acceptedId
+	});
+	const receipt = createMessageReceiptFromOutboundResults({
+		kind: resolveWhatsAppReceiptKind(params.kind),
+		results: receiptSources
+	});
+	const accepted = requireWhatsAppAcceptedSendResult({
+		kind: params.kind,
+		messageId,
+		receipt,
+		keys: acceptedIds.map((id) => ({ id })),
+		providerAccepted: true
+	});
+	activityAccountedWhatsAppSendResults.add(accepted);
+	params.results.push(accepted);
+	return true;
+}
+/** Merge accepted local sends with nested partial receipts without inventing provider ids. */
+function mergeWhatsAppAcceptedSendError(params) {
+	const nested = isChannelPartialDeliveryError(params.error) ? params.error.deliveryResult : void 0;
+	const receiptSources = [];
+	const recordedIds = /* @__PURE__ */ new Set();
+	for (const result of params.results) {
+		const resultIds = listWhatsAppSendResultMessageIds(result);
+		if (resultIds.every((messageId) => recordedIds.has(messageId))) continue;
+		receiptSources.push({
+			channel: "whatsapp",
+			messageId: result.messageId,
+			...result.receipt ? { receipt: result.receipt } : {}
+		});
+		for (const messageId of resultIds) recordedIds.add(messageId);
+	}
+	const unrecordedNestedIds = uniqueStrings([...nested?.receipt ? listMessageReceiptPlatformIds(nested.receipt) : [], ...normalizeStringEntries(nested?.messageIds ?? [])]).filter((messageId) => messageId !== "unknown").filter((messageId) => !recordedIds.has(messageId));
+	const nestedMessageId = unrecordedNestedIds[0];
+	if (nested?.receipt && nestedMessageId) {
+		receiptSources.push({
+			channel: "whatsapp",
+			messageId: nestedMessageId,
+			receipt: nested.receipt
+		});
+		for (const messageId of listMessageReceiptPlatformIds(nested.receipt)) recordedIds.add(messageId);
+	}
+	for (const messageId of unrecordedNestedIds) if (!recordedIds.has(messageId)) receiptSources.push({
+		channel: "whatsapp",
+		messageId
+	});
+	const receipt = enrichWhatsAppDeliveryReceipt({
+		receipt: createMessageReceiptFromOutboundResults({
+			kind: resolveWhatsAppReceiptKind(params.kind),
+			results: receiptSources
+		}),
+		sources: [...params.results.flatMap((result) => result.receipt ? [result.receipt] : []), ...nested?.receipt ? [nested.receipt] : []]
+	});
+	const messageIds = listMessageReceiptPlatformIds(receipt);
+	if (messageIds.length === 0) return params.error;
+	let cause = params.error;
+	const visitedPartialErrors = /* @__PURE__ */ new Set();
+	while (isChannelPartialDeliveryError(cause) && cause instanceof Error && cause.cause !== void 0 && !visitedPartialErrors.has(cause)) {
+		visitedPartialErrors.add(cause);
+		cause = cause.cause;
+	}
+	return createChannelPartialDeliveryError(cause, {
+		...nested,
+		messageIds,
+		receipt,
+		visibleReplySent: true
+	});
+}
+function combineWhatsAppSendResults(kind, results) {
+	const messageId = uniqueStrings(results.flatMap(listWhatsAppSendResultMessageIds))[0];
+	if (!messageId) throw createWhatsAppProviderNotAcceptedError(kind);
+	const keys = results.flatMap((result) => result.keys);
+	const combined = {
+		kind,
+		messageId,
+		receipt: createWhatsAppSendReceipt(kind, keys),
+		keys,
+		providerAccepted: results.some((result) => result.providerAccepted)
+	};
+	if (results.some((result) => activityAccountedWhatsAppSendResults.has(result))) activityAccountedWhatsAppSendResults.add(combined);
+	return combined;
+}
+function listWhatsAppSendResultMessageIds(result) {
+	const receiptIds = result.receipt ? listMessageReceiptPlatformIds(result.receipt) : [];
+	if (receiptIds.length > 0) return receiptIds;
+	const keyIds = normalizeStringEntries(result.keys.map((key) => key.id));
+	if (keyIds.length > 0) return uniqueStrings(keyIds);
+	return [];
+}
+//#endregion
 //#region extensions/whatsapp/src/outbound-media-contract.ts
 const WHATSAPP_VOICE_FILE_NAME = "voice.ogg";
 const WHATSAPP_VOICE_SAMPLE_RATE_HZ = 48e3;
@@ -101,7 +343,7 @@ function inferWhatsAppMediaKind(media, resolvedContentType) {
 function normalizeWhatsAppLoadedMedia(media, mediaUrl) {
 	const filenameMimeType = mimeTypeFromFilePath(media.fileName);
 	const normalizedContentType = normalizeMimeType(media.contentType);
-	const resolvedContentType = !normalizedContentType || normalizedContentType === "application/octet-stream" ? filenameMimeType ?? media.contentType : media.contentType;
+	const resolvedContentType = !normalizedContentType || normalizedContentType === "application/octet-stream" ? filenameMimeType ?? normalizedContentType : normalizedContentType;
 	const kind = inferWhatsAppMediaKind(media, resolvedContentType);
 	const mimetype = kind === "audio" && isWhatsAppNativeVoiceAudio({
 		contentType: media.contentType,
@@ -167,13 +409,13 @@ function deriveWhatsAppDocumentFileName(mediaUrl) {
 }
 //#endregion
 //#region extensions/whatsapp/src/send.ts
-const outboundLog = createSubsystemLogger("gateway/channels/whatsapp").child("outbound");
+const outboundLog = createSubsystemLogger$1("gateway/channels/whatsapp").child("outbound");
 function supportsForcedDocumentDelivery(kind) {
 	return kind === "image" || kind === "video";
 }
 function buildWhatsAppMediaSendState(params) {
 	const { media, caption } = params;
-	const forceDocumentDelivery = Boolean(params.forceDocument && supportsForcedDocumentDelivery(media.kind));
+	const forceDocumentDelivery = Boolean(params.forceDocument && supportsForcedDocumentDelivery(media.kind)) || media.kind === "document" && (media.mimetype.startsWith("image/") || media.mimetype.startsWith("video/"));
 	let text = caption ?? "";
 	let documentFileName = media.kind === "document" ? media.fileName : void 0;
 	let visibleTextAfterVoice;
@@ -219,6 +461,12 @@ function resolveActualSentRemoteJid(result, fallbackJid) {
 	return fallbackJid;
 }
 async function sendMessageWhatsApp(to, body, options) {
+	return await sendWhatsAppUploadFile(to, body, options);
+}
+async function sendWhatsAppUploadFile(to, body, options) {
+	return await withWhatsAppLogicalDeliveryActivity(() => sendMessageWhatsAppInActivityScope(to, body, options));
+}
+async function sendMessageWhatsAppInActivityScope(to, body, options) {
 	let text = options.preserveLeadingWhitespace ? body : normalizeWhatsAppPayloadText(body);
 	const jid = toWhatsappJid(to);
 	const mediaUrls = resolveAdditiveWhatsAppMediaUrls(options);
@@ -259,6 +507,7 @@ async function sendMessageWhatsApp(to, body, options) {
 		correlationId,
 		to: redactedTo
 	});
+	const acceptedResults = [];
 	try {
 		const redactedJid = redactIdentifier(jid);
 		let mediaBuffer;
@@ -268,13 +517,24 @@ async function sendMessageWhatsApp(to, body, options) {
 		let forceDocumentDelivery = false;
 		let media;
 		if (mediaPayload) media = await prepareWhatsAppOutboundMedia(mediaPayload, primaryMediaUrl);
-		else if (primaryMediaUrl) 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);
+		else if (primaryMediaUrl) {
+			const loadedMedia = await loadOutboundMediaFromUrl(primaryMediaUrl, {
+				maxBytes: resolveWhatsAppMediaMaxBytes(account),
+				optimizeImages: options.forceDocument ? false : void 0,
+				mediaAccess: options.mediaAccess,
+				mediaLocalRoots: options.mediaLocalRoots,
+				mediaReadFile: options.mediaReadFile
+			});
+			const mediaWithRequestedType = options.contentType ? {
+				...loadedMedia,
+				contentType: options.contentType,
+				kind: void 0
+			} : loadedMedia;
+			media = await prepareWhatsAppOutboundMedia(options.fileName ? {
+				...mediaWithRequestedType,
+				fileName: options.fileName
+			} : mediaWithRequestedType, primaryMediaUrl);
+		}
 		if (media) {
 			const mediaSendState = buildWhatsAppMediaSendState({
 				media,
@@ -295,7 +555,14 @@ async function sendMessageWhatsApp(to, body, options) {
 		}, "sending message");
 		if (!isWhatsAppNewsletterJid(jid)) {
 			await active.assertSendReady?.(to);
-			await active.sendComposingTo(to);
+			try {
+				await active.sendComposingTo(to);
+			} catch (err) {
+				logger.warn({
+					err: String(err),
+					jid: redactedJid
+				}, "failed to send composing presence; continuing message delivery");
+			}
 		}
 		const accountId = Boolean(options.accountId?.trim()) ? resolvedAccountId : void 0;
 		const sendOptions = options.gifPlayback || forceDocumentDelivery || accountId || documentFileName || options.quotedMessageKey ? {
@@ -305,8 +572,9 @@ async function sendMessageWhatsApp(to, body, options) {
 			...options.quotedMessageKey ? { quotedMessageKey: options.quotedMessageKey } : {},
 			accountId
 		} : void 0;
-		const result = sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType);
-		const messageId = result?.messageId ?? "unknown";
+		const result = requireWhatsAppAcceptedSendResult(sendOptions ? await active.sendMessage(to, text, mediaBuffer, mediaType, sendOptions) : await active.sendMessage(to, text, mediaBuffer, mediaType));
+		acceptedResults.push(result);
+		const messageId = result.messageId;
 		const sentRemoteJid = resolveActualSentRemoteJid(result, jid);
 		const trailingTextChunks = [visibleTextAfterVoice, ...textChunks].filter((chunk) => Boolean(chunk));
 		if (trailingTextChunks.length > 0) {
@@ -315,9 +583,10 @@ async function sendMessageWhatsApp(to, body, options) {
 				toJid: sentRemoteJid
 			});
 			for (const trailingText of trailingTextChunks) {
-				const trailingResult = sendOptions ? await active.sendMessage(to, trailingText, void 0, void 0, sendOptions) : await active.sendMessage(to, trailingText, void 0, void 0);
+				const trailingResult = requireWhatsAppAcceptedSendResult(sendOptions ? await active.sendMessage(to, trailingText, void 0, void 0, sendOptions) : await active.sendMessage(to, trailingText, void 0, void 0));
+				acceptedResults.push(trailingResult);
 				await options.onDeliveryResult?.({
-					messageId: trailingResult?.messageId ?? "unknown",
+					messageId: trailingResult.messageId,
 					toJid: resolveActualSentRemoteJid(trailingResult, jid)
 				});
 			}
@@ -338,7 +607,12 @@ async function sendMessageWhatsApp(to, body, options) {
 			to: redactedTo,
 			hasMedia
 		}, "failed to send via web session");
-		throw err;
+		const firstAccepted = acceptedResults[0];
+		throw mergeWhatsAppAcceptedSendError({
+			error: err,
+			kind: firstAccepted?.kind ?? (hasMedia ? "media" : "text"),
+			results: acceptedResults
+		});
 	}
 }
 async function sendTypingWhatsApp(to, options) {
@@ -413,7 +687,8 @@ async function sendPollWhatsApp(to, poll, options) {
 			maxSelections: normalized.maxSelections
 		}, "sending poll");
 		if (!isWhatsAppNewsletterJid(jid)) await active.assertSendReady?.(to);
-		const messageId = (await active.sendPoll(to, normalized))?.messageId ?? "unknown";
+		const result = requireWhatsAppAcceptedSendResult(await active.sendPoll(to, normalized));
+		const messageId = result.messageId;
 		const durationMs = Date.now() - startedAt;
 		outboundLog.info(`Sent poll ${messageId} -> ${redactedJid} (${durationMs}ms)`);
 		logger.info({
@@ -422,7 +697,7 @@ async function sendPollWhatsApp(to, poll, options) {
 		}, "sent poll");
 		return {
 			messageId,
-			toJid: jid
+			toJid: resolveActualSentRemoteJid(result, jid)
 		};
 	} catch (err) {
 		logger.error({
@@ -433,4 +708,4 @@ async function sendPollWhatsApp(to, poll, options) {
 	}
 }
 //#endregion
-export { normalizeWhatsAppOutboundPayload as a, prepareWhatsAppOutboundMedia as c, sendTypingWhatsApp as i, resolveWhatsAppDocumentFileName as l, sendPollWhatsApp as n, normalizeWhatsAppPayloadText as o, sendReactionWhatsApp as r, normalizeWhatsAppPayloadTextPreservingIndentation as s, sendMessageWhatsApp as t, resolveWhatsAppReactionLevel as u };
+export { resolveWhatsAppDocumentFileName as _, sendWhatsAppUploadFile as a, normalizeWhatsAppPayloadTextPreservingIndentation as c, listWhatsAppSendResultMessageIds as d, mergeWhatsAppAcceptedSendError as f, withWhatsAppLogicalDeliveryActivity as g, rememberWhatsAppPartialSend as h, sendTypingWhatsApp as i, prepareWhatsAppOutboundMedia as l, rememberWhatsAppAcceptedSend as m, sendPollWhatsApp as n, normalizeWhatsAppOutboundPayload as o, normalizeWhatsAppSendResult as p, sendReactionWhatsApp as r, normalizeWhatsAppPayloadText as s, sendMessageWhatsApp as t, combineWhatsAppSendResults as u, resolveWhatsAppReactionLevel as v };