@gakr-gakr/whatsapp 0.1.0

package/src/auto-reply/monitor/broadcast.ts

@@ -0,0 +1,153 @@
+import type { AckReactionHandle } from "autobot/plugin-sdk/channel-feedback";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import type { resolveAgentRoute } from "autobot/plugin-sdk/routing";
+import { buildAgentSessionKey, deriveLastRoutePolicy } from "autobot/plugin-sdk/routing";
+import {
+  buildAgentMainSessionKey,
+  DEFAULT_MAIN_KEY,
+  normalizeAgentId,
+} from "autobot/plugin-sdk/routing";
+import { resolveWhatsAppGroupSessionRoute } from "../../group-session-key.js";
+import { formatError } from "../../session.js";
+import { whatsappInboundLog } from "../loggers.js";
+import type { WebInboundMsg } from "../types.js";
+import type { GroupHistoryEntry } from "./inbound-context.js";
+
+function buildBroadcastRouteKeys(params: {
+  cfg: AutoBotConfig;
+  msg: WebInboundMsg;
+  route: ReturnType<typeof resolveAgentRoute>;
+  peerId: string;
+  agentId: string;
+}) {
+  const sessionKey = buildAgentSessionKey({
+    agentId: params.agentId,
+    channel: "whatsapp",
+    accountId: params.route.accountId,
+    peer: {
+      kind: params.msg.chatType === "group" ? "group" : "direct",
+      id: params.peerId,
+    },
+    dmScope: params.cfg.session?.dmScope,
+    identityLinks: params.cfg.session?.identityLinks,
+  });
+  const mainSessionKey = buildAgentMainSessionKey({
+    agentId: params.agentId,
+    mainKey: DEFAULT_MAIN_KEY,
+  });
+
+  return {
+    sessionKey,
+    mainSessionKey,
+    lastRoutePolicy: deriveLastRoutePolicy({
+      sessionKey,
+      mainSessionKey,
+    }),
+  };
+}
+
+export async function maybeBroadcastMessage(params: {
+  cfg: AutoBotConfig;
+  msg: WebInboundMsg;
+  peerId: string;
+  route: ReturnType<typeof resolveAgentRoute>;
+  groupHistoryKey: string;
+  groupHistories: Map<string, GroupHistoryEntry[]>;
+  processMessage: (
+    msg: WebInboundMsg,
+    route: ReturnType<typeof resolveAgentRoute>,
+    groupHistoryKey: string,
+    opts?: {
+      groupHistory?: GroupHistoryEntry[];
+      suppressGroupHistoryClear?: boolean;
+      preflightAudioTranscript?: string | null;
+      ackAlreadySent?: boolean;
+      ackReaction?: AckReactionHandle | null;
+    },
+  ) => Promise<boolean>;
+  preflightAudioTranscript?: string | null;
+  ackAlreadySent?: boolean;
+  ackReaction?: AckReactionHandle | null;
+}) {
+  const broadcastAgents = params.cfg.broadcast?.[params.peerId];
+  if (!broadcastAgents || !Array.isArray(broadcastAgents)) {
+    return false;
+  }
+  if (broadcastAgents.length === 0) {
+    return false;
+  }
+
+  const strategy = params.cfg.broadcast?.strategy || "parallel";
+  whatsappInboundLog.info(`Broadcasting message to ${broadcastAgents.length} agents (${strategy})`);
+
+  const agentIds = params.cfg.agents?.list?.map((agent) => normalizeAgentId(agent.id));
+  const hasKnownAgents = (agentIds?.length ?? 0) > 0;
+  const groupHistorySnapshot =
+    params.msg.chatType === "group"
+      ? (params.groupHistories.get(params.groupHistoryKey) ?? [])
+      : undefined;
+
+  const processForAgent = async (agentId: string): Promise<boolean> => {
+    const normalizedAgentId = normalizeAgentId(agentId);
+    if (hasKnownAgents && !agentIds?.includes(normalizedAgentId)) {
+      whatsappInboundLog.warn(`Broadcast agent ${agentId} not found in agents.list; skipping`);
+      return false;
+    }
+    const routeKeys = buildBroadcastRouteKeys({
+      cfg: params.cfg,
+      msg: params.msg,
+      route: params.route,
+      peerId: params.peerId,
+      agentId: normalizedAgentId,
+    });
+    const baseAgentRoute = {
+      ...params.route,
+      agentId: normalizedAgentId,
+      ...routeKeys,
+    };
+    const agentRoute =
+      params.msg.chatType === "group"
+        ? resolveWhatsAppGroupSessionRoute(baseAgentRoute)
+        : baseAgentRoute;
+
+    try {
+      const opts: {
+        groupHistory?: GroupHistoryEntry[];
+        suppressGroupHistoryClear: true;
+        preflightAudioTranscript?: string | null;
+        ackAlreadySent?: boolean;
+        ackReaction?: AckReactionHandle | null;
+      } = {
+        groupHistory: groupHistorySnapshot,
+        suppressGroupHistoryClear: true,
+      };
+      if (params.preflightAudioTranscript !== undefined) {
+        opts.preflightAudioTranscript = params.preflightAudioTranscript;
+      }
+      if (params.ackAlreadySent === true) {
+        opts.ackAlreadySent = true;
+      }
+      if (params.ackReaction !== undefined) {
+        opts.ackReaction = params.ackReaction;
+      }
+      return await params.processMessage(params.msg, agentRoute, params.groupHistoryKey, opts);
+    } catch (err) {
+      whatsappInboundLog.error(`Broadcast agent ${agentId} failed: ${formatError(err)}`);
+      return false;
+    }
+  };
+
+  if (strategy === "sequential") {
+    for (const agentId of broadcastAgents) {
+      await processForAgent(agentId);
+    }
+  } else {
+    await Promise.allSettled(broadcastAgents.map(processForAgent));
+  }
+
+  if (params.msg.chatType === "group") {
+    params.groupHistories.set(params.groupHistoryKey, []);
+  }
+
+  return true;
+}

package/src/auto-reply/monitor/commands.ts

@@ -0,0 +1,19 @@
+export function stripMentionsForCommand(
+  text: string,
+  mentionRegexes: RegExp[],
+  selfE164?: string | null,
+) {
+  let result = text;
+  for (const re of mentionRegexes) {
+    result = result.replace(re, " ");
+  }
+  if (selfE164) {
+    // `selfE164` is usually like "+1234"; strip down to digits so we can match "+?1234" safely.
+    const digits = selfE164.replace(/\D/g, "");
+    if (digits) {
+      const pattern = new RegExp(`\\+?${digits}`, "g");
+      result = result.replace(pattern, " ");
+    }
+  }
+  return result.replace(/\s+/g, " ").trim();
+}

package/src/auto-reply/monitor/echo.ts

@@ -0,0 +1,64 @@
+export type EchoTracker = {
+  rememberText: (
+    text: string | undefined,
+    opts: {
+      combinedBody?: string;
+      combinedBodySessionKey?: string;
+      logVerboseMessage?: boolean;
+    },
+  ) => void;
+  has: (key: string) => boolean;
+  forget: (key: string) => void;
+  buildCombinedKey: (params: { sessionKey: string; combinedBody: string }) => string;
+};
+
+export function createEchoTracker(params: {
+  maxItems?: number;
+  logVerbose?: (msg: string) => void;
+}): EchoTracker {
+  const recentlySent = new Set<string>();
+  const maxItems = Math.max(1, params.maxItems ?? 100);
+
+  const buildCombinedKey = (p: { sessionKey: string; combinedBody: string }) =>
+    `combined:${p.sessionKey}:${p.combinedBody}`;
+
+  const trim = () => {
+    while (recentlySent.size > maxItems) {
+      const firstKey = recentlySent.values().next().value;
+      if (!firstKey) {
+        break;
+      }
+      recentlySent.delete(firstKey);
+    }
+  };
+
+  const rememberText: EchoTracker["rememberText"] = (text, opts) => {
+    if (!text) {
+      return;
+    }
+    recentlySent.add(text);
+    if (opts.combinedBody && opts.combinedBodySessionKey) {
+      recentlySent.add(
+        buildCombinedKey({
+          sessionKey: opts.combinedBodySessionKey,
+          combinedBody: opts.combinedBody,
+        }),
+      );
+    }
+    if (opts.logVerboseMessage) {
+      params.logVerbose?.(
+        `Added to echo detection set (size now: ${recentlySent.size}): ${text.slice(0, 50)}...`,
+      );
+    }
+    trim();
+  };
+
+  return {
+    rememberText,
+    has: (key) => recentlySent.has(key),
+    forget: (key) => {
+      recentlySent.delete(key);
+    },
+    buildCombinedKey,
+  };
+}

package/src/auto-reply/monitor/group-activation.runtime.ts

@@ -0,0 +1 @@
+export { normalizeGroupActivation } from "autobot/plugin-sdk/group-activation";

package/src/auto-reply/monitor/group-activation.ts

@@ -0,0 +1,73 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "autobot/plugin-sdk/routing";
+import { updateSessionStore } from "autobot/plugin-sdk/session-store-runtime";
+import { resolveWhatsAppLegacyGroupSessionKey } from "../../group-session-key.js";
+import { resolveWhatsAppInboundPolicy } from "../../inbound-policy.js";
+import { loadSessionStore, resolveStorePath } from "../config.runtime.js";
+import { normalizeGroupActivation } from "./group-activation.runtime.js";
+
+function hasNamedWhatsAppAccounts(cfg: AutoBotConfig) {
+  const accountIds = Object.keys(cfg.channels?.whatsapp?.accounts ?? {});
+  return accountIds.some((accountId) => normalizeAccountId(accountId) !== DEFAULT_ACCOUNT_ID);
+}
+
+function isActivationOnlyEntry(
+  entry:
+    | {
+        groupActivation?: unknown;
+        sessionId?: unknown;
+        updatedAt?: unknown;
+      }
+    | undefined,
+) {
+  return (
+    entry?.groupActivation !== undefined &&
+    typeof entry?.sessionId !== "string" &&
+    typeof entry?.updatedAt !== "number"
+  );
+}
+
+export async function resolveGroupActivationFor(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  agentId: string;
+  sessionKey: string;
+  conversationId: string;
+}) {
+  const storePath = resolveStorePath(params.cfg.session?.store, {
+    agentId: params.agentId,
+  });
+  const store = loadSessionStore(storePath);
+  const legacySessionKey = resolveWhatsAppLegacyGroupSessionKey({
+    sessionKey: params.sessionKey,
+    accountId: params.accountId,
+  });
+  const legacyEntry = legacySessionKey ? store[legacySessionKey] : undefined;
+  const scopedEntry = store[params.sessionKey];
+  const normalizedAccountId = normalizeAccountId(params.accountId);
+  const ignoreScopedActivation =
+    normalizedAccountId === DEFAULT_ACCOUNT_ID &&
+    hasNamedWhatsAppAccounts(params.cfg) &&
+    isActivationOnlyEntry(scopedEntry);
+  const activation =
+    (ignoreScopedActivation ? undefined : scopedEntry?.groupActivation) ??
+    legacyEntry?.groupActivation;
+  if (activation !== undefined && scopedEntry?.groupActivation === undefined) {
+    await updateSessionStore(storePath, (nextStore) => {
+      const nextScopedEntry = nextStore[params.sessionKey];
+      if (nextScopedEntry?.groupActivation !== undefined) {
+        return;
+      }
+      nextStore[params.sessionKey] = {
+        ...nextScopedEntry,
+        groupActivation: activation,
+      };
+    });
+  }
+  const requireMention = resolveWhatsAppInboundPolicy({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  }).resolveConversationRequireMention(params.conversationId);
+  const defaultActivation = !requireMention ? "always" : "mention";
+  return normalizeGroupActivation(activation) ?? defaultActivation;
+}

package/src/auto-reply/monitor/group-gating.runtime.ts

@@ -0,0 +1,8 @@
+export {
+  implicitMentionKindWhen,
+  resolveInboundMentionDecision,
+} from "autobot/plugin-sdk/channel-mention-gating";
+export { hasControlCommand } from "autobot/plugin-sdk/command-detection";
+export { createChannelHistoryWindow } from "autobot/plugin-sdk/reply-history";
+export { parseActivationCommand } from "autobot/plugin-sdk/group-activation";
+export { normalizeE164 } from "../../text-runtime.js";

package/src/auto-reply/monitor/group-gating.ts

@@ -0,0 +1,218 @@
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+import {
+  getPrimaryIdentityId,
+  getReplyContext,
+  getSelfIdentity,
+  getSenderIdentity,
+  identitiesOverlap,
+} from "../../identity.js";
+import { resolveWhatsAppInboundPolicy } from "../../inbound-policy.js";
+import type { MentionConfig } from "../mentions.js";
+import { buildMentionConfig, debugMention, resolveOwnerList } from "../mentions.js";
+import type { WebInboundMsg } from "../types.js";
+import { stripMentionsForCommand } from "./commands.js";
+import { resolveGroupActivationFor } from "./group-activation.js";
+import {
+  hasControlCommand,
+  implicitMentionKindWhen,
+  normalizeE164,
+  parseActivationCommand,
+  createChannelHistoryWindow,
+  resolveInboundMentionDecision,
+} from "./group-gating.runtime.js";
+import { noteGroupMember } from "./group-members.js";
+
+export type GroupHistoryEntry = {
+  sender: string;
+  body: string;
+  timestamp?: number;
+  id?: string;
+  senderJid?: string;
+};
+
+type ApplyGroupGatingParams = {
+  cfg: AutoBotConfig;
+  msg: WebInboundMsg;
+  mentionText?: string;
+  deferMissingMention?: boolean;
+  conversationId: string;
+  groupHistoryKey: string;
+  agentId: string;
+  sessionKey: string;
+  baseMentionConfig: MentionConfig;
+  authDir?: string;
+  groupHistories: Map<string, GroupHistoryEntry[]>;
+  groupHistoryLimit: number;
+  groupMemberNames: Map<string, Map<string, string>>;
+  selfChatMode?: boolean;
+  logVerbose: (msg: string) => void;
+  replyLogger: { debug: (obj: unknown, msg: string) => void };
+};
+
+function isOwnerSender(baseMentionConfig: MentionConfig, msg: WebInboundMsg) {
+  const sender = normalizeE164(getSenderIdentity(msg).e164 ?? "");
+  if (!sender) {
+    return false;
+  }
+  const owners = resolveOwnerList(baseMentionConfig, getSelfIdentity(msg).e164 ?? undefined);
+  return owners.includes(sender);
+}
+
+function recordPendingGroupHistoryEntry(params: {
+  msg: WebInboundMsg;
+  body?: string;
+  groupHistories: Map<string, GroupHistoryEntry[]>;
+  groupHistoryKey: string;
+  groupHistoryLimit: number;
+}) {
+  const senderIdentity = getSenderIdentity(params.msg);
+  const sender =
+    senderIdentity.name && senderIdentity.e164
+      ? `${senderIdentity.name} (${senderIdentity.e164})`
+      : (senderIdentity.name ??
+        senderIdentity.e164 ??
+        getPrimaryIdentityId(senderIdentity) ??
+        "Unknown");
+  createChannelHistoryWindow({ historyMap: params.groupHistories }).record({
+    historyKey: params.groupHistoryKey,
+    limit: params.groupHistoryLimit,
+    entry: {
+      sender,
+      body: params.body ?? params.msg.body,
+      timestamp: params.msg.timestamp,
+      id: params.msg.id,
+      senderJid: senderIdentity.jid ?? params.msg.senderJid,
+    },
+  });
+}
+
+function skipGroupMessageAndStoreHistory(
+  params: ApplyGroupGatingParams,
+  verboseMessage: string,
+  body?: string,
+) {
+  params.logVerbose(verboseMessage);
+  recordPendingGroupHistoryEntry({
+    msg: params.msg,
+    body,
+    groupHistories: params.groupHistories,
+    groupHistoryKey: params.groupHistoryKey,
+    groupHistoryLimit: params.groupHistoryLimit,
+  });
+  return { shouldProcess: false } as const;
+}
+
+export async function applyGroupGating(params: ApplyGroupGatingParams) {
+  const sender = getSenderIdentity(params.msg);
+  const self = getSelfIdentity(params.msg, params.authDir);
+  const inboundPolicy = resolveWhatsAppInboundPolicy({
+    cfg: params.cfg,
+    accountId: params.msg.accountId,
+    selfE164: self.e164 ?? null,
+  });
+  const conversationGroupPolicy = inboundPolicy.resolveConversationGroupPolicy(
+    params.conversationId,
+  );
+  if (conversationGroupPolicy.allowlistEnabled && !conversationGroupPolicy.allowed) {
+    params.logVerbose(
+      `Dropping message from unregistered WhatsApp group ${params.conversationId}. Add the group JID to channels.whatsapp.groups, or add "*" there to admit all groups. Sender authorization still applies.`,
+    );
+    return { shouldProcess: false };
+  }
+
+  noteGroupMember(
+    params.groupMemberNames,
+    params.groupHistoryKey,
+    sender.e164 ?? undefined,
+    sender.name ?? undefined,
+  );
+
+  const baseMentionConfig = {
+    ...params.baseMentionConfig,
+    allowFrom: inboundPolicy.configuredAllowFrom,
+  };
+  const mentionConfig = {
+    ...buildMentionConfig(params.cfg, params.agentId),
+    allowFrom: inboundPolicy.configuredAllowFrom,
+  };
+  const mentionMsg =
+    params.mentionText !== undefined ? { ...params.msg, body: params.mentionText } : params.msg;
+  const commandBody = stripMentionsForCommand(
+    mentionMsg.body,
+    mentionConfig.mentionRegexes,
+    self.e164,
+  );
+  const activationCommand = parseActivationCommand(commandBody);
+  const owner = isOwnerSender(baseMentionConfig, params.msg);
+  const shouldBypassMention = owner && hasControlCommand(commandBody, params.cfg);
+
+  if (activationCommand.hasCommand && !owner) {
+    return skipGroupMessageAndStoreHistory(
+      params,
+      `Ignoring /activation from non-owner in group ${params.conversationId}`,
+    );
+  }
+
+  const mentionDebug = debugMention(mentionMsg, mentionConfig, params.authDir);
+  params.replyLogger.debug(
+    {
+      conversationId: params.conversationId,
+      wasMentioned: mentionDebug.wasMentioned,
+      ...mentionDebug.details,
+    },
+    "group mention debug",
+  );
+  const wasMentioned = mentionDebug.wasMentioned;
+  const activation = await resolveGroupActivationFor({
+    cfg: params.cfg,
+    accountId: inboundPolicy.account.accountId,
+    agentId: params.agentId,
+    sessionKey: params.sessionKey,
+    conversationId: params.conversationId,
+  });
+  const requireMention = activation !== "always";
+  const replyContext = getReplyContext(params.msg, params.authDir);
+  const sharedNumberSelfChat = params.selfChatMode === true;
+  // Detect reply-to-bot: compare JIDs, LIDs, and E.164 numbers.
+  // WhatsApp may report the quoted message sender as either a phone JID
+  // (xxxxx@s.whatsapp.net) or a LID (xxxxx@lid), so we compare both.
+  // But in shared-number/selfChatMode setups, replies from the same self number
+  // should not count as implicit bot mentions unless the message explicitly
+  // mentioned the bot in text.
+  const implicitReplyToSelf = sharedNumberSelfChat && identitiesOverlap(self, sender);
+  const implicitMentionKinds = implicitMentionKindWhen(
+    "quoted_bot",
+    !implicitReplyToSelf && identitiesOverlap(self, replyContext?.sender),
+  );
+  const mentionDecision = resolveInboundMentionDecision({
+    facts: {
+      canDetectMention: true,
+      wasMentioned,
+      implicitMentionKinds,
+    },
+    policy: {
+      isGroup: true,
+      requireMention,
+      allowTextCommands: false,
+      hasControlCommand: false,
+      commandAuthorized: false,
+    },
+  });
+  const effectiveWasMentioned = mentionDecision.effectiveWasMentioned || shouldBypassMention;
+  params.msg.wasMentioned = effectiveWasMentioned;
+  if (!shouldBypassMention && requireMention && mentionDecision.shouldSkip) {
+    if (params.deferMissingMention === true) {
+      params.logVerbose(
+        `Deferring group mention skip until audio preflight completes in ${params.conversationId}`,
+      );
+      return { shouldProcess: false, needsMentionText: true } as const;
+    }
+    return skipGroupMessageAndStoreHistory(
+      params,
+      `Group message stored for context (no mention detected) in ${params.conversationId}: ${mentionMsg.body}`,
+      params.mentionText,
+    );
+  }
+
+  return { shouldProcess: true };
+}

package/src/auto-reply/monitor/group-members.ts

@@ -0,0 +1,65 @@
+import { normalizeE164 } from "../../text-runtime.js";
+
+function appendNormalizedUnique(entries: Iterable<string>, seen: Set<string>, ordered: string[]) {
+  for (const entry of entries) {
+    const normalized = normalizeE164(entry) ?? entry;
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    ordered.push(normalized);
+  }
+}
+
+export function noteGroupMember(
+  groupMemberNames: Map<string, Map<string, string>>,
+  conversationId: string,
+  e164?: string,
+  name?: string,
+) {
+  if (!e164 || !name) {
+    return;
+  }
+  const normalized = normalizeE164(e164);
+  const key = normalized ?? e164;
+  if (!key) {
+    return;
+  }
+  let roster = groupMemberNames.get(conversationId);
+  if (!roster) {
+    roster = new Map();
+    groupMemberNames.set(conversationId, roster);
+  }
+  roster.set(key, name);
+}
+
+export function formatGroupMembers(params: {
+  participants: string[] | undefined;
+  roster: Map<string, string> | undefined;
+  fallbackE164?: string;
+}) {
+  const { participants, roster, fallbackE164 } = params;
+  const seen = new Set<string>();
+  const ordered: string[] = [];
+  if (participants?.length) {
+    appendNormalizedUnique(participants, seen, ordered);
+  }
+  if (roster) {
+    appendNormalizedUnique(roster.keys(), seen, ordered);
+  }
+  if (ordered.length === 0 && fallbackE164) {
+    const normalized = normalizeE164(fallbackE164) ?? fallbackE164;
+    if (normalized) {
+      ordered.push(normalized);
+    }
+  }
+  if (ordered.length === 0) {
+    return undefined;
+  }
+  return ordered
+    .map((entry) => {
+      const name = roster?.get(entry);
+      return name ? `${name} (${entry})` : entry;
+    })
+    .join(", ");
+}

package/src/auto-reply/monitor/inbound-context.ts

@@ -0,0 +1,92 @@
+import {
+  evaluateSupplementalContextVisibility,
+  filterSupplementalContextItems,
+} from "autobot/plugin-sdk/security-runtime";
+import {
+  getComparableIdentityValues,
+  getReplyContext,
+  type WhatsAppIdentity,
+  type WhatsAppReplyContext,
+} from "../../identity.js";
+import { normalizeE164 } from "../../text-runtime.js";
+import type { WebInboundMsg } from "../types.js";
+
+export type GroupHistoryEntry = {
+  sender: string;
+  body: string;
+  timestamp?: number;
+  id?: string;
+  senderJid?: string;
+};
+
+type ContextVisibilityMode = "all" | "allowlist" | "allowlist_quote";
+
+function isWhatsAppSupplementalSenderAllowed(params: {
+  allowFrom: string[];
+  sender?: WhatsAppIdentity | null;
+}): boolean {
+  if (params.allowFrom.includes("*")) {
+    return true;
+  }
+  const senderValues = new Set(getComparableIdentityValues(params.sender));
+  if (senderValues.size === 0) {
+    return false;
+  }
+  for (const entry of params.allowFrom) {
+    const rawEntry = entry.trim();
+    if (!rawEntry) {
+      continue;
+    }
+    const normalizedEntry = normalizeE164(rawEntry);
+    if ((normalizedEntry && senderValues.has(normalizedEntry)) || senderValues.has(rawEntry)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function resolveVisibleWhatsAppGroupHistory(params: {
+  history: GroupHistoryEntry[];
+  mode: ContextVisibilityMode;
+  groupPolicy: "open" | "allowlist" | "disabled";
+  groupAllowFrom: string[];
+}): GroupHistoryEntry[] {
+  if (params.groupPolicy !== "allowlist") {
+    return params.history;
+  }
+  return filterSupplementalContextItems({
+    items: params.history,
+    mode: params.mode,
+    kind: "history",
+    isSenderAllowed: (entry) =>
+      isWhatsAppSupplementalSenderAllowed({
+        allowFrom: params.groupAllowFrom,
+        sender: entry.senderJid ? { jid: entry.senderJid } : null,
+      }),
+  }).items;
+}
+
+export function resolveVisibleWhatsAppReplyContext(params: {
+  msg: WebInboundMsg;
+  authDir?: string;
+  mode: ContextVisibilityMode;
+  groupPolicy: "open" | "allowlist" | "disabled";
+  groupAllowFrom: string[];
+}): WhatsAppReplyContext | null {
+  const replyTo = getReplyContext(params.msg, params.authDir);
+  if (!replyTo) {
+    return null;
+  }
+  const include = evaluateSupplementalContextVisibility({
+    mode: params.mode,
+    kind: "quote",
+    senderAllowed:
+      params.msg.chatType !== "group" || params.groupPolicy !== "allowlist"
+        ? true
+        : isWhatsAppSupplementalSenderAllowed({
+            allowFrom: params.groupAllowFrom,
+            sender: replyTo.sender,
+          }),
+  }).include;
+  return include ? replyTo : null;
+}