remoteclaw 0.1.0-next.cd6ddde → 0.1.0-next.cf9ccbe

package/dist/ack-reactions-Diu9O24z.js

@@ -0,0 +1,621 @@
+import { t as normalizeChatType } from "./chat-type-CH3W-zKy.js";
+import { t as formatCliCommand } from "./command-format-BiiNHkWG.js";
+import { O as CURRENT_MESSAGE_MARKER, a as resolveTimezone, i as formatZonedTimestamp, p as resolveUserTimezone, r as formatUtcTimestamp, u as resolveSenderLabel } from "./reply-CL5VMSKN.js";
+import { n as formatTimeAgo } from "./format-relative-Czf5fUjn.js";
+import { r as formatUncaughtError, t as extractErrorCode } from "./errors-0dfGxeYQ.js";
+import process from "node:process";
+import { setTimeout as setTimeout$1 } from "node:timers/promises";
+
+//#region src/infra/backoff.ts
+function computeBackoff(policy, attempt) {
+	const base = policy.initialMs * policy.factor ** Math.max(attempt - 1, 0);
+	const jitter = base * policy.jitter * Math.random();
+	return Math.min(policy.maxMs, Math.round(base + jitter));
+}
+async function sleepWithAbort(ms, abortSignal) {
+	if (ms <= 0) return;
+	try {
+		await setTimeout$1(ms, void 0, { signal: abortSignal });
+	} catch (err) {
+		if (abortSignal?.aborted) throw new Error("aborted", { cause: err });
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/auto-reply/inbound-debounce.ts
+const resolveMs = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return;
+	return Math.max(0, Math.trunc(value));
+};
+const resolveChannelOverride = (params) => {
+	if (!params.byChannel) return;
+	return resolveMs(params.byChannel[params.channel]);
+};
+function resolveInboundDebounceMs(params) {
+	const inbound = params.cfg.messages?.inbound;
+	const override = resolveMs(params.overrideMs);
+	const byChannel = resolveChannelOverride({
+		byChannel: inbound?.byChannel,
+		channel: params.channel
+	});
+	const base = resolveMs(inbound?.debounceMs);
+	return override ?? byChannel ?? base ?? 0;
+}
+function createInboundDebouncer(params) {
+	const buffers = /* @__PURE__ */ new Map();
+	const defaultDebounceMs = Math.max(0, Math.trunc(params.debounceMs));
+	const resolveDebounceMs = (item) => {
+		const resolved = params.resolveDebounceMs?.(item);
+		if (typeof resolved !== "number" || !Number.isFinite(resolved)) return defaultDebounceMs;
+		return Math.max(0, Math.trunc(resolved));
+	};
+	const flushBuffer = async (key, buffer) => {
+		buffers.delete(key);
+		if (buffer.timeout) {
+			clearTimeout(buffer.timeout);
+			buffer.timeout = null;
+		}
+		if (buffer.items.length === 0) return;
+		try {
+			await params.onFlush(buffer.items);
+		} catch (err) {
+			params.onError?.(err, buffer.items);
+		}
+	};
+	const flushKey = async (key) => {
+		const buffer = buffers.get(key);
+		if (!buffer) return;
+		await flushBuffer(key, buffer);
+	};
+	const scheduleFlush = (key, buffer) => {
+		if (buffer.timeout) clearTimeout(buffer.timeout);
+		buffer.timeout = setTimeout(() => {
+			flushBuffer(key, buffer);
+		}, buffer.debounceMs);
+		buffer.timeout.unref?.();
+	};
+	const enqueue = async (item) => {
+		const key = params.buildKey(item);
+		const debounceMs = resolveDebounceMs(item);
+		if (!(debounceMs > 0 && (params.shouldDebounce?.(item) ?? true)) || !key) {
+			if (key && buffers.has(key)) await flushKey(key);
+			await params.onFlush([item]);
+			return;
+		}
+		const existing = buffers.get(key);
+		if (existing) {
+			existing.items.push(item);
+			existing.debounceMs = debounceMs;
+			scheduleFlush(key, existing);
+			return;
+		}
+		const buffer = {
+			items: [item],
+			timeout: null,
+			debounceMs
+		};
+		buffers.set(key, buffer);
+		scheduleFlush(key, buffer);
+	};
+	return {
+		enqueue,
+		flushKey
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/history.ts
+const HISTORY_CONTEXT_MARKER = "[Chat messages since your last reply - for context]";
+const DEFAULT_GROUP_HISTORY_LIMIT = 50;
+/** Maximum number of group history keys to retain (LRU eviction when exceeded). */
+const MAX_HISTORY_KEYS = 1e3;
+/**
+* Evict oldest keys from a history map when it exceeds MAX_HISTORY_KEYS.
+* Uses Map's insertion order for LRU-like behavior.
+*/
+function evictOldHistoryKeys(historyMap, maxKeys = MAX_HISTORY_KEYS) {
+	if (historyMap.size <= maxKeys) return;
+	const keysToDelete = historyMap.size - maxKeys;
+	const iterator = historyMap.keys();
+	for (let i = 0; i < keysToDelete; i++) {
+		const key = iterator.next().value;
+		if (key !== void 0) historyMap.delete(key);
+	}
+}
+function buildHistoryContext(params) {
+	const { historyText, currentMessage } = params;
+	const lineBreak = params.lineBreak ?? "\n";
+	if (!historyText.trim()) return currentMessage;
+	return [
+		HISTORY_CONTEXT_MARKER,
+		historyText,
+		"",
+		CURRENT_MESSAGE_MARKER,
+		currentMessage
+	].join(lineBreak);
+}
+function appendHistoryEntry(params) {
+	const { historyMap, historyKey, entry } = params;
+	if (params.limit <= 0) return [];
+	const history = historyMap.get(historyKey) ?? [];
+	history.push(entry);
+	while (history.length > params.limit) history.shift();
+	if (historyMap.has(historyKey)) historyMap.delete(historyKey);
+	historyMap.set(historyKey, history);
+	evictOldHistoryKeys(historyMap);
+	return history;
+}
+function recordPendingHistoryEntry(params) {
+	return appendHistoryEntry(params);
+}
+function recordPendingHistoryEntryIfEnabled(params) {
+	if (!params.entry) return [];
+	if (params.limit <= 0) return [];
+	return recordPendingHistoryEntry({
+		historyMap: params.historyMap,
+		historyKey: params.historyKey,
+		entry: params.entry,
+		limit: params.limit
+	});
+}
+function buildPendingHistoryContextFromMap(params) {
+	if (params.limit <= 0) return params.currentMessage;
+	return buildHistoryContextFromEntries({
+		entries: params.historyMap.get(params.historyKey) ?? [],
+		currentMessage: params.currentMessage,
+		formatEntry: params.formatEntry,
+		lineBreak: params.lineBreak,
+		excludeLast: false
+	});
+}
+function clearHistoryEntries(params) {
+	params.historyMap.set(params.historyKey, []);
+}
+function clearHistoryEntriesIfEnabled(params) {
+	if (params.limit <= 0) return;
+	clearHistoryEntries({
+		historyMap: params.historyMap,
+		historyKey: params.historyKey
+	});
+}
+function buildHistoryContextFromEntries(params) {
+	const lineBreak = params.lineBreak ?? "\n";
+	const entries = params.excludeLast === false ? params.entries : params.entries.slice(0, -1);
+	if (entries.length === 0) return params.currentMessage;
+	return buildHistoryContext({
+		historyText: entries.map(params.formatEntry).join(lineBreak),
+		currentMessage: params.currentMessage,
+		lineBreak
+	});
+}
+
+//#endregion
+//#region src/infra/unhandled-rejections.ts
+const handlers = /* @__PURE__ */ new Set();
+const FATAL_ERROR_CODES = new Set([
+	"ERR_OUT_OF_MEMORY",
+	"ERR_SCRIPT_EXECUTION_TIMEOUT",
+	"ERR_WORKER_OUT_OF_MEMORY",
+	"ERR_WORKER_UNCAUGHT_EXCEPTION",
+	"ERR_WORKER_INITIALIZATION_FAILED"
+]);
+const CONFIG_ERROR_CODES = new Set([
+	"INVALID_CONFIG",
+	"MISSING_API_KEY",
+	"MISSING_CREDENTIALS"
+]);
+const TRANSIENT_NETWORK_CODES = new Set([
+	"ECONNRESET",
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"ETIMEDOUT",
+	"ESOCKETTIMEDOUT",
+	"ECONNABORTED",
+	"EPIPE",
+	"EHOSTUNREACH",
+	"ENETUNREACH",
+	"EAI_AGAIN",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_DNS_RESOLVE_FAILED",
+	"UND_ERR_CONNECT",
+	"UND_ERR_SOCKET",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_BODY_TIMEOUT"
+]);
+const TRANSIENT_NETWORK_ERROR_NAMES = new Set([
+	"AbortError",
+	"ConnectTimeoutError",
+	"HeadersTimeoutError",
+	"BodyTimeoutError",
+	"TimeoutError"
+]);
+const TRANSIENT_NETWORK_MESSAGE_CODE_RE = /\b(ECONNRESET|ECONNREFUSED|ENOTFOUND|ETIMEDOUT|ESOCKETTIMEDOUT|ECONNABORTED|EPIPE|EHOSTUNREACH|ENETUNREACH|EAI_AGAIN|UND_ERR_CONNECT_TIMEOUT|UND_ERR_DNS_RESOLVE_FAILED|UND_ERR_CONNECT|UND_ERR_SOCKET|UND_ERR_HEADERS_TIMEOUT|UND_ERR_BODY_TIMEOUT)\b/i;
+const TRANSIENT_NETWORK_MESSAGE_SNIPPETS = [
+	"getaddrinfo",
+	"socket hang up",
+	"network error",
+	"network is unreachable",
+	"temporary failure in name resolution"
+];
+function getErrorCause(err) {
+	if (!err || typeof err !== "object") return;
+	return err.cause;
+}
+function getErrorName(err) {
+	if (!err || typeof err !== "object") return "";
+	const name = err.name;
+	return typeof name === "string" ? name : "";
+}
+function extractErrorCodeOrErrno(err) {
+	const code = extractErrorCode(err);
+	if (code) return code.trim().toUpperCase();
+	if (!err || typeof err !== "object") return;
+	const errno = err.errno;
+	if (typeof errno === "string" && errno.trim()) return errno.trim().toUpperCase();
+	if (typeof errno === "number" && Number.isFinite(errno)) return String(errno);
+}
+function extractErrorCodeWithCause(err) {
+	const direct = extractErrorCode(err);
+	if (direct) return direct;
+	return extractErrorCode(getErrorCause(err));
+}
+function collectErrorCandidates(err) {
+	const queue = [err];
+	const seen = /* @__PURE__ */ new Set();
+	const candidates = [];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current == null || seen.has(current)) continue;
+		seen.add(current);
+		candidates.push(current);
+		if (!current || typeof current !== "object") continue;
+		const maybeNested = [
+			current.cause,
+			current.reason,
+			current.original,
+			current.error,
+			current.data
+		];
+		const errors = current.errors;
+		if (Array.isArray(errors)) maybeNested.push(...errors);
+		for (const nested of maybeNested) if (nested != null && !seen.has(nested)) queue.push(nested);
+	}
+	return candidates;
+}
+/**
+* Checks if an error is an AbortError.
+* These are typically intentional cancellations (e.g., during shutdown) and shouldn't crash.
+*/
+function isAbortError(err) {
+	if (!err || typeof err !== "object") return false;
+	if (("name" in err ? String(err.name) : "") === "AbortError") return true;
+	if (("message" in err && typeof err.message === "string" ? err.message : "") === "This operation was aborted") return true;
+	return false;
+}
+function isFatalError(err) {
+	const code = extractErrorCodeWithCause(err);
+	return code !== void 0 && FATAL_ERROR_CODES.has(code);
+}
+function isConfigError(err) {
+	const code = extractErrorCodeWithCause(err);
+	return code !== void 0 && CONFIG_ERROR_CODES.has(code);
+}
+/**
+* Checks if an error is a transient network error that shouldn't crash the gateway.
+* These are typically temporary connectivity issues that will resolve on their own.
+*/
+function isTransientNetworkError(err) {
+	if (!err) return false;
+	for (const candidate of collectErrorCandidates(err)) {
+		const code = extractErrorCodeOrErrno(candidate);
+		if (code && TRANSIENT_NETWORK_CODES.has(code)) return true;
+		const name = getErrorName(candidate);
+		if (name && TRANSIENT_NETWORK_ERROR_NAMES.has(name)) return true;
+		if (candidate instanceof TypeError && candidate.message === "fetch failed") return true;
+		if (!candidate || typeof candidate !== "object") continue;
+		const rawMessage = candidate.message;
+		const message = typeof rawMessage === "string" ? rawMessage.toLowerCase().trim() : "";
+		if (!message) continue;
+		if (TRANSIENT_NETWORK_MESSAGE_CODE_RE.test(message)) return true;
+		if (message === "fetch failed") return true;
+		if (TRANSIENT_NETWORK_MESSAGE_SNIPPETS.some((snippet) => message.includes(snippet))) return true;
+	}
+	return false;
+}
+function registerUnhandledRejectionHandler(handler) {
+	handlers.add(handler);
+	return () => {
+		handlers.delete(handler);
+	};
+}
+function isUnhandledRejectionHandled(reason) {
+	for (const handler of handlers) try {
+		if (handler(reason)) return true;
+	} catch (err) {
+		console.error("[remoteclaw] Unhandled rejection handler failed:", err instanceof Error ? err.stack ?? err.message : err);
+	}
+	return false;
+}
+function installUnhandledRejectionHandler() {
+	process.on("unhandledRejection", (reason, _promise) => {
+		if (isUnhandledRejectionHandled(reason)) return;
+		if (isAbortError(reason)) {
+			console.warn("[remoteclaw] Suppressed AbortError:", formatUncaughtError(reason));
+			return;
+		}
+		if (isFatalError(reason)) {
+			console.error("[remoteclaw] FATAL unhandled rejection:", formatUncaughtError(reason));
+			process.exit(1);
+			return;
+		}
+		if (isConfigError(reason)) {
+			console.error("[remoteclaw] CONFIGURATION ERROR - requires fix:", formatUncaughtError(reason));
+			process.exit(1);
+			return;
+		}
+		if (isTransientNetworkError(reason)) {
+			console.warn("[remoteclaw] Non-fatal unhandled rejection (continuing):", formatUncaughtError(reason));
+			return;
+		}
+		console.error("[remoteclaw] Unhandled promise rejection:", formatUncaughtError(reason));
+		process.exit(1);
+	});
+}
+
+//#endregion
+//#region src/config/runtime-group-policy.ts
+function resolveRuntimeGroupPolicy(params) {
+	const configuredFallbackPolicy = params.configuredFallbackPolicy ?? "open";
+	const missingProviderFallbackPolicy = params.missingProviderFallbackPolicy ?? "allowlist";
+	return {
+		groupPolicy: params.providerConfigPresent ? params.groupPolicy ?? params.defaultGroupPolicy ?? configuredFallbackPolicy : params.groupPolicy ?? missingProviderFallbackPolicy,
+		providerMissingFallbackApplied: !params.providerConfigPresent && params.groupPolicy === void 0
+	};
+}
+function resolveDefaultGroupPolicy(cfg) {
+	return cfg.channels?.defaults?.groupPolicy;
+}
+const GROUP_POLICY_BLOCKED_LABEL = {
+	group: "group messages",
+	guild: "guild messages",
+	room: "room messages",
+	channel: "channel messages",
+	space: "space messages"
+};
+/**
+* Standard provider runtime policy:
+* - configured provider fallback: open
+* - missing provider fallback: allowlist (fail-closed)
+*/
+function resolveOpenProviderRuntimeGroupPolicy(params) {
+	return resolveRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy,
+		configuredFallbackPolicy: "open",
+		missingProviderFallbackPolicy: "allowlist"
+	});
+}
+/**
+* Strict provider runtime policy:
+* - configured provider fallback: allowlist
+* - missing provider fallback: allowlist (fail-closed)
+*/
+function resolveAllowlistProviderRuntimeGroupPolicy(params) {
+	return resolveRuntimeGroupPolicy({
+		providerConfigPresent: params.providerConfigPresent,
+		groupPolicy: params.groupPolicy,
+		defaultGroupPolicy: params.defaultGroupPolicy,
+		configuredFallbackPolicy: "allowlist",
+		missingProviderFallbackPolicy: "allowlist"
+	});
+}
+const warnedMissingProviderGroupPolicy = /* @__PURE__ */ new Set();
+function warnMissingProviderGroupPolicyFallbackOnce(params) {
+	if (!params.providerMissingFallbackApplied) return false;
+	const key = `${params.providerKey}:${params.accountId ?? "*"}`;
+	if (warnedMissingProviderGroupPolicy.has(key)) return false;
+	warnedMissingProviderGroupPolicy.add(key);
+	const blockedLabel = params.blockedLabel?.trim() || "group messages";
+	params.log(`${params.providerKey}: channels.${params.providerKey} is missing; defaulting groupPolicy to "allowlist" (${blockedLabel} blocked until explicitly configured).`);
+	return true;
+}
+
+//#endregion
+//#region src/pairing/pairing-messages.ts
+function buildPairingReply(params) {
+	const { channel, idLine, code } = params;
+	return [
+		"RemoteClaw: access not configured.",
+		"",
+		idLine,
+		"",
+		`Pairing code: ${code}`,
+		"",
+		"Ask the bot owner to approve with:",
+		formatCliCommand(`remoteclaw pairing approve ${channel} ${code}`)
+	].join("\n");
+}
+
+//#endregion
+//#region src/channels/mention-gating.ts
+function resolveMentionGating(params) {
+	const implicit = params.implicitMention === true;
+	const bypass = params.shouldBypassMention === true;
+	const effectiveWasMentioned = params.wasMentioned || implicit || bypass;
+	return {
+		effectiveWasMentioned,
+		shouldSkip: params.requireMention && params.canDetectMention && !effectiveWasMentioned
+	};
+}
+function resolveMentionGatingWithBypass(params) {
+	const shouldBypassMention = params.isGroup && params.requireMention && !params.wasMentioned && !(params.hasAnyMention ?? false) && params.allowTextCommands && params.commandAuthorized && params.hasControlCommand;
+	return {
+		...resolveMentionGating({
+			requireMention: params.requireMention,
+			canDetectMention: params.canDetectMention,
+			wasMentioned: params.wasMentioned,
+			implicitMention: params.implicitMention,
+			shouldBypassMention
+		}),
+		shouldBypassMention
+	};
+}
+
+//#endregion
+//#region src/auto-reply/envelope.ts
+function sanitizeEnvelopeHeaderPart(value) {
+	return value.replace(/\r\n|\r|\n/g, " ").replaceAll("[", "(").replaceAll("]", ")").replace(/\s+/g, " ").trim();
+}
+function resolveEnvelopeFormatOptions(cfg) {
+	const defaults = cfg?.agents?.defaults;
+	return {
+		timezone: defaults?.envelopeTimezone,
+		includeTimestamp: defaults?.envelopeTimestamp !== "off",
+		includeElapsed: defaults?.envelopeElapsed !== "off",
+		userTimezone: defaults?.userTimezone
+	};
+}
+function normalizeEnvelopeOptions(options) {
+	const includeTimestamp = options?.includeTimestamp !== false;
+	const includeElapsed = options?.includeElapsed !== false;
+	return {
+		timezone: options?.timezone?.trim() || "local",
+		includeTimestamp,
+		includeElapsed,
+		userTimezone: options?.userTimezone
+	};
+}
+function resolveEnvelopeTimezone(options) {
+	const trimmed = options.timezone?.trim();
+	if (!trimmed) return { mode: "local" };
+	const lowered = trimmed.toLowerCase();
+	if (lowered === "utc" || lowered === "gmt") return { mode: "utc" };
+	if (lowered === "local" || lowered === "host") return { mode: "local" };
+	if (lowered === "user") return {
+		mode: "iana",
+		timeZone: resolveUserTimezone(options.userTimezone)
+	};
+	const explicit = resolveTimezone(trimmed);
+	return explicit ? {
+		mode: "iana",
+		timeZone: explicit
+	} : { mode: "utc" };
+}
+function formatTimestamp(ts, options) {
+	if (!ts) return;
+	const resolved = normalizeEnvelopeOptions(options);
+	if (!resolved.includeTimestamp) return;
+	const date = ts instanceof Date ? ts : new Date(ts);
+	if (Number.isNaN(date.getTime())) return;
+	const zone = resolveEnvelopeTimezone(resolved);
+	const weekday = (() => {
+		try {
+			if (zone.mode === "utc") return new Intl.DateTimeFormat("en-US", {
+				timeZone: "UTC",
+				weekday: "short"
+			}).format(date);
+			if (zone.mode === "local") return new Intl.DateTimeFormat("en-US", { weekday: "short" }).format(date);
+			return new Intl.DateTimeFormat("en-US", {
+				timeZone: zone.timeZone,
+				weekday: "short"
+			}).format(date);
+		} catch {
+			return;
+		}
+	})();
+	const formatted = zone.mode === "utc" ? formatUtcTimestamp(date) : zone.mode === "local" ? formatZonedTimestamp(date) : formatZonedTimestamp(date, { timeZone: zone.timeZone });
+	if (!formatted) return;
+	return weekday ? `${weekday} ${formatted}` : formatted;
+}
+function formatAgentEnvelope(params) {
+	const parts = [sanitizeEnvelopeHeaderPart(params.channel?.trim() || "Channel")];
+	const resolved = normalizeEnvelopeOptions(params.envelope);
+	let elapsed;
+	if (resolved.includeElapsed && params.timestamp && params.previousTimestamp) {
+		const elapsedMs = (params.timestamp instanceof Date ? params.timestamp.getTime() : params.timestamp) - (params.previousTimestamp instanceof Date ? params.previousTimestamp.getTime() : params.previousTimestamp);
+		elapsed = Number.isFinite(elapsedMs) && elapsedMs >= 0 ? formatTimeAgo(elapsedMs, { suffix: false }) : void 0;
+	}
+	if (params.from?.trim()) {
+		const from = sanitizeEnvelopeHeaderPart(params.from.trim());
+		parts.push(elapsed ? `${from} +${elapsed}` : from);
+	} else if (elapsed) parts.push(`+${elapsed}`);
+	if (params.host?.trim()) parts.push(sanitizeEnvelopeHeaderPart(params.host.trim()));
+	if (params.ip?.trim()) parts.push(sanitizeEnvelopeHeaderPart(params.ip.trim()));
+	const ts = formatTimestamp(params.timestamp, resolved);
+	if (ts) parts.push(ts);
+	return `${`[${parts.join(" ")}]`} ${params.body}`;
+}
+function formatInboundEnvelope(params) {
+	const chatType = normalizeChatType(params.chatType);
+	const isDirect = !chatType || chatType === "direct";
+	const resolvedSenderRaw = params.senderLabel?.trim() || resolveSenderLabel(params.sender ?? {});
+	const resolvedSender = resolvedSenderRaw ? sanitizeEnvelopeHeaderPart(resolvedSenderRaw) : "";
+	const body = !isDirect && resolvedSender ? `${resolvedSender}: ${params.body}` : params.body;
+	return formatAgentEnvelope({
+		channel: params.channel,
+		from: params.from,
+		timestamp: params.timestamp,
+		previousTimestamp: params.previousTimestamp,
+		envelope: params.envelope,
+		body
+	});
+}
+function formatInboundFromLabel(params) {
+	if (params.isGroup) {
+		const label = params.groupLabel?.trim() || params.groupFallback || "Group";
+		const id = params.groupId?.trim();
+		return id ? `${label} id:${id}` : label;
+	}
+	const directLabel = params.directLabel.trim();
+	const directId = params.directId?.trim();
+	if (!directId || directId === directLabel) return directLabel;
+	return `${directLabel} id:${directId}`;
+}
+
+//#endregion
+//#region src/channels/ack-reactions.ts
+function shouldAckReaction(params) {
+	const scope = params.scope ?? "group-mentions";
+	if (scope === "off" || scope === "none") return false;
+	if (scope === "all") return true;
+	if (scope === "direct") return params.isDirect;
+	if (scope === "group-all") return params.isGroup;
+	if (scope === "group-mentions") {
+		if (!params.isMentionableGroup) return false;
+		if (!params.requireMention) return false;
+		if (!params.canDetectMention) return false;
+		return params.effectiveWasMentioned || params.shouldBypassMention === true;
+	}
+	return false;
+}
+function shouldAckReactionForWhatsApp(params) {
+	if (!params.emoji) return false;
+	if (params.isDirect) return params.directEnabled;
+	if (!params.isGroup) return false;
+	if (params.groupMode === "never") return false;
+	if (params.groupMode === "always") return true;
+	return shouldAckReaction({
+		scope: "group-mentions",
+		isDirect: false,
+		isGroup: true,
+		isMentionableGroup: true,
+		requireMention: true,
+		canDetectMention: true,
+		effectiveWasMentioned: params.wasMentioned,
+		shouldBypassMention: params.groupActivated
+	});
+}
+function removeAckReactionAfterReply(params) {
+	if (!params.removeAfterReply) return;
+	if (!params.ackReactionPromise) return;
+	if (!params.ackReactionValue) return;
+	params.ackReactionPromise.then((didAck) => {
+		if (!didAck) return;
+		params.remove().catch((err) => params.onError?.(err));
+	});
+}
+
+//#endregion
+export { createInboundDebouncer as C, sleepWithAbort as E, recordPendingHistoryEntryIfEnabled as S, computeBackoff as T, registerUnhandledRejectionHandler as _, formatInboundEnvelope as a, buildPendingHistoryContextFromMap as b, resolveMentionGating as c, GROUP_POLICY_BLOCKED_LABEL as d, resolveAllowlistProviderRuntimeGroupPolicy as f, installUnhandledRejectionHandler as g, warnMissingProviderGroupPolicyFallbackOnce as h, formatAgentEnvelope as i, resolveMentionGatingWithBypass as l, resolveOpenProviderRuntimeGroupPolicy as m, shouldAckReaction as n, formatInboundFromLabel as o, resolveDefaultGroupPolicy as p, shouldAckReactionForWhatsApp as r, resolveEnvelopeFormatOptions as s, removeAckReactionAfterReply as t, buildPairingReply as u, DEFAULT_GROUP_HISTORY_LIMIT as v, resolveInboundDebounceMs as w, clearHistoryEntriesIfEnabled as x, buildHistoryContextFromEntries as y };