@gakr-gakr/whatsapp 0.1.0

package/src/inbound/outbound-mentions.ts

@@ -0,0 +1,260 @@
+import type { AnyMessageContent } from "baileys";
+
+export type WhatsAppOutboundMentionParticipant =
+  | string
+  | {
+      id?: string | null;
+      lid?: string | null;
+      phoneNumber?: string | null;
+      e164?: string | null;
+    };
+
+export type WhatsAppOutboundMentionResolution = {
+  text: string;
+  mentionedJids: string[];
+};
+
+const CODE_FENCE_RE = /```[\s\S]*?```/g;
+const INLINE_CODE_RE = /`[^`\n]+`/g;
+const OUTBOUND_MENTION_RE = /@(\+?\d+)/g;
+const KNOWN_USER_JID_RE = /^(\d+)(?::\d+)?@(s\.whatsapp\.net|hosted|lid|hosted\.lid|c\.us)$/i;
+const PHONE_JID_DOMAIN_RE = /^(s\.whatsapp\.net|hosted|c\.us)$/i;
+const LID_JID_DOMAIN_RE = /^(lid|hosted\.lid)$/i;
+
+type TextRange = {
+  start: number;
+  end: number;
+};
+
+type MentionTarget = {
+  mentionJid: string;
+  replacementText?: string;
+};
+
+function isWhatsAppGroupJid(jid: string): boolean {
+  return jid.endsWith("@g.us");
+}
+
+export function mayContainWhatsAppOutboundMention(text: string): boolean {
+  return /@\+?\d/.test(text);
+}
+
+function collectCodeRanges(text: string): TextRange[] {
+  const ranges: TextRange[] = [];
+  for (const match of text.matchAll(CODE_FENCE_RE)) {
+    ranges.push({ start: match.index, end: match.index + match[0].length });
+  }
+  for (const match of text.matchAll(INLINE_CODE_RE)) {
+    const start = match.index;
+    if (ranges.some((range) => start >= range.start && start < range.end)) {
+      continue;
+    }
+    ranges.push({ start, end: start + match[0].length });
+  }
+  return ranges.toSorted((a, b) => a.start - b.start);
+}
+
+function isInRange(index: number, ranges: readonly TextRange[]): boolean {
+  return ranges.some((range) => index >= range.start && index < range.end);
+}
+
+function normalizeKnownUserJid(value: string): string | null {
+  const trimmed = value.replace(/^whatsapp:/i, "").trim();
+  const jidMatch = trimmed.match(KNOWN_USER_JID_RE);
+  if (jidMatch) {
+    const domain =
+      jidMatch[2].toLowerCase() === "c.us" ? "s.whatsapp.net" : jidMatch[2].toLowerCase();
+    return `${jidMatch[1]}@${domain}`;
+  }
+  const digits = trimmed.startsWith("+")
+    ? trimmed.replace(/\D/g, "")
+    : /^\d+$/.test(trimmed)
+      ? trimmed
+      : "";
+  return digits ? `${digits}@s.whatsapp.net` : null;
+}
+
+function extractKnownJidParts(value: string): { user: string; domain: string } | null {
+  const normalized = normalizeKnownUserJid(value);
+  if (!normalized) {
+    return null;
+  }
+  const match = normalized.match(/^(\d+)@(.+)$/);
+  return match ? { user: match[1], domain: match[2] } : null;
+}
+
+function extractPhoneDigits(value: string | null | undefined): string | null {
+  if (!value) {
+    return null;
+  }
+  const trimmed = value.replace(/^whatsapp:/i, "").trim();
+  if (trimmed.startsWith("+") || /^\d+$/.test(trimmed)) {
+    const digits = trimmed.replace(/\D/g, "");
+    return digits || null;
+  }
+  const parts = extractKnownJidParts(trimmed);
+  return parts && PHONE_JID_DOMAIN_RE.test(parts.domain) ? parts.user : null;
+}
+
+function extractLidDigits(value: string | null | undefined): string | null {
+  if (!value) {
+    return null;
+  }
+  const parts = extractKnownJidParts(value);
+  return parts && LID_JID_DOMAIN_RE.test(parts.domain) ? parts.user : null;
+}
+
+function isLidJid(jid: string): boolean {
+  const parts = extractKnownJidParts(jid);
+  return Boolean(parts && LID_JID_DOMAIN_RE.test(parts.domain));
+}
+
+function lidReplacementText(jid: string): string | undefined {
+  const parts = extractKnownJidParts(jid);
+  if (!parts || !LID_JID_DOMAIN_RE.test(parts.domain)) {
+    return undefined;
+  }
+  return `@${parts.user}`;
+}
+
+function participantValues(participant: WhatsAppOutboundMentionParticipant): {
+  id?: string | null;
+  lid?: string | null;
+  phoneNumber?: string | null;
+  e164?: string | null;
+} {
+  return typeof participant === "string" ? { id: participant } : participant;
+}
+
+function chooseMentionJid(participant: WhatsAppOutboundMentionParticipant): string | null {
+  const values = participantValues(participant);
+  const idJid = normalizeKnownUserJid(values.id ?? "");
+  const lidJid = normalizeKnownUserJid(values.lid ?? "");
+  return (
+    (idJid && isLidJid(idJid) ? idJid : null) ??
+    (lidJid && isLidJid(lidJid) ? lidJid : null) ??
+    idJid ??
+    lidJid ??
+    normalizeKnownUserJid(values.phoneNumber ?? "") ??
+    normalizeKnownUserJid(values.e164 ?? "")
+  );
+}
+
+function buildMentionTargetMaps(participants: readonly WhatsAppOutboundMentionParticipant[]): {
+  byPhone: Map<string, MentionTarget>;
+  byLid: Map<string, MentionTarget>;
+} {
+  const byPhone = new Map<string, MentionTarget>();
+  const byLid = new Map<string, MentionTarget>();
+  for (const participant of participants) {
+    const mentionJid = chooseMentionJid(participant);
+    if (!mentionJid) {
+      continue;
+    }
+    const target = {
+      mentionJid,
+      ...(isLidJid(mentionJid) ? { replacementText: lidReplacementText(mentionJid) } : {}),
+    };
+    const values = participantValues(participant);
+    for (const value of [values.id, values.phoneNumber, values.e164]) {
+      const digits = extractPhoneDigits(value);
+      if (digits && !byPhone.has(digits)) {
+        byPhone.set(digits, target);
+      }
+    }
+    for (const value of [values.id, values.lid]) {
+      const digits = extractLidDigits(value);
+      if (digits && !byLid.has(digits)) {
+        byLid.set(digits, target);
+      }
+    }
+  }
+  return { byPhone, byLid };
+}
+
+function shouldSkipMentionAt(
+  text: string,
+  index: number,
+  end: number,
+  codeRanges: readonly TextRange[],
+): boolean {
+  if (isInRange(index, codeRanges)) {
+    return true;
+  }
+  const previous = index > 0 ? text[index - 1] : "";
+  const next = text[end] ?? "";
+  return Boolean((previous && /[\w@]/.test(previous)) || (next && /[\w@]/.test(next)));
+}
+
+export function resolveWhatsAppOutboundMentions(params: {
+  chatJid: string;
+  text: string;
+  participants?: readonly WhatsAppOutboundMentionParticipant[];
+}): WhatsAppOutboundMentionResolution {
+  if (
+    !isWhatsAppGroupJid(params.chatJid) ||
+    !mayContainWhatsAppOutboundMention(params.text) ||
+    !params.participants?.length
+  ) {
+    return { text: params.text, mentionedJids: [] };
+  }
+
+  const { byPhone, byLid } = buildMentionTargetMaps(params.participants);
+  if (byPhone.size === 0 && byLid.size === 0) {
+    return { text: params.text, mentionedJids: [] };
+  }
+
+  const codeRanges = collectCodeRanges(params.text);
+  const replacements: Array<{ start: number; end: number; text: string }> = [];
+  const mentionedJids: string[] = [];
+  const seenMentionJids = new Set<string>();
+
+  for (const match of params.text.matchAll(OUTBOUND_MENTION_RE)) {
+    const start = match.index;
+    const token = match[0];
+    if (shouldSkipMentionAt(params.text, start, start + token.length, codeRanges)) {
+      continue;
+    }
+    const digits = match[1].replace(/\D/g, "");
+    const target = token.startsWith("@+")
+      ? (byPhone.get(digits) ?? byLid.get(digits))
+      : (byLid.get(digits) ?? byPhone.get(digits));
+    if (!target) {
+      continue;
+    }
+    if (!seenMentionJids.has(target.mentionJid)) {
+      seenMentionJids.add(target.mentionJid);
+      mentionedJids.push(target.mentionJid);
+    }
+    if (target.replacementText && target.replacementText !== token) {
+      replacements.push({
+        start,
+        end: start + token.length,
+        text: target.replacementText,
+      });
+    }
+  }
+
+  if (replacements.length === 0) {
+    return { text: params.text, mentionedJids };
+  }
+
+  let text = "";
+  let cursor = 0;
+  for (const replacement of replacements) {
+    text += params.text.slice(cursor, replacement.start);
+    text += replacement.text;
+    cursor = replacement.end;
+  }
+  text += params.text.slice(cursor);
+  return { text, mentionedJids };
+}
+
+export function addWhatsAppOutboundMentionsToContent(
+  content: AnyMessageContent,
+  mentionedJids: readonly string[],
+): AnyMessageContent {
+  return mentionedJids.length > 0
+    ? ({ ...content, mentions: [...mentionedJids] } as AnyMessageContent)
+    : content;
+}

package/src/inbound/runtime-api.ts

@@ -0,0 +1,7 @@
+export {
+  DisconnectReason,
+  downloadMediaMessage,
+  isJidGroup,
+  normalizeMessageContent,
+} from "baileys";
+export { saveMediaBuffer } from "./save-media.runtime.js";

package/src/inbound/save-media.runtime.ts

@@ -0,0 +1 @@
+export { saveMediaBuffer } from "autobot/plugin-sdk/media-store";

package/src/inbound/send-api.ts

@@ -0,0 +1,203 @@
+import type {
+  AnyMessageContent,
+  MiscMessageGenerationOptions,
+  WAMessage,
+  WAPresence,
+} from "baileys";
+import { recordChannelActivity } from "autobot/plugin-sdk/channel-activity-runtime";
+import { resolveWhatsAppDocumentFileName } from "../document-filename.js";
+import { isWhatsAppNewsletterJid } from "../normalize.js";
+import { buildQuotedMessageOptions } from "../quoted-message.js";
+import { toWhatsappJid, toWhatsappJidWithLid } from "../text-runtime.js";
+import {
+  addWhatsAppOutboundMentionsToContent,
+  type WhatsAppOutboundMentionResolution,
+} from "./outbound-mentions.js";
+import {
+  combineWhatsAppSendResults,
+  normalizeWhatsAppSendResult,
+  type WhatsAppSendResult,
+} from "./send-result.js";
+import type { ActiveWebSendOptions } from "./types.js";
+
+function recordWhatsAppOutbound(accountId: string) {
+  recordChannelActivity({
+    channel: "whatsapp",
+    accountId,
+    direction: "outbound",
+  });
+}
+
+function supportsForcedDocumentMediaType(mediaType: string): boolean {
+  return mediaType.startsWith("image/") || mediaType.startsWith("video/");
+}
+
+export function createWebSendApi(params: {
+  sock: {
+    sendMessage: (
+      jid: string,
+      content: AnyMessageContent,
+      options?: MiscMessageGenerationOptions,
+    ) => Promise<WAMessage | undefined>;
+    sendPresenceUpdate: (presence: WAPresence, jid?: string) => Promise<unknown>;
+  };
+  defaultAccountId: string;
+  resolveOutboundMentions?: (params: {
+    jid: string;
+    text: string;
+  }) => Promise<WhatsAppOutboundMentionResolution> | WhatsAppOutboundMentionResolution;
+  // When provided, lets outbound resolve `{phone}@s.whatsapp.net` to `{lid}@lid`
+  // via Baileys' lid-mapping-{phone-digits}.json files in the auth dir, so
+  // proactive sends to LID-addressed contacts reach the recipient instead of
+  // ending up in a sender-only ghost chat (#67378). Defaults to PN-only.
+  authDir?: string;
+}) {
+  const resolveOutboundJid = (recipient: string): string =>
+    params.authDir
+      ? toWhatsappJidWithLid(recipient, { authDir: params.authDir })
+      : toWhatsappJid(recipient);
+  const resolveMentions = async (
+    jid: string,
+    text: string,
+  ): Promise<WhatsAppOutboundMentionResolution> =>
+    params.resolveOutboundMentions
+      ? await params.resolveOutboundMentions({ jid, text })
+      : { text, mentionedJids: [] };
+
+  return {
+    sendMessage: async (
+      to: string,
+      text: string,
+      mediaBuffer?: Buffer,
+      mediaType?: string,
+      sendOptions?: ActiveWebSendOptions,
+    ): Promise<WhatsAppSendResult> => {
+      const jid = resolveOutboundJid(to);
+      let payload: AnyMessageContent;
+      if (mediaBuffer) {
+        mediaType ??= "application/octet-stream";
+      }
+      const shouldSendAudioText = Boolean(
+        mediaBuffer && mediaType?.startsWith("audio/") && text.trim(),
+      );
+      const resolvedPayloadText = shouldSendAudioText
+        ? { text, mentionedJids: [] }
+        : await resolveMentions(jid, text);
+      if (mediaBuffer && mediaType) {
+        if (sendOptions?.asDocument === true && supportsForcedDocumentMediaType(mediaType)) {
+          const fileName = resolveWhatsAppDocumentFileName({
+            fileName: sendOptions?.fileName,
+            mimetype: mediaType,
+          });
+          payload = {
+            document: mediaBuffer,
+            fileName,
+            caption: resolvedPayloadText.text || undefined,
+            mimetype: mediaType,
+          };
+        } else if (mediaType.startsWith("image/")) {
+          payload = {
+            image: mediaBuffer,
+            caption: resolvedPayloadText.text || undefined,
+            mimetype: mediaType,
+          };
+        } else if (mediaType.startsWith("audio/")) {
+          payload = { audio: mediaBuffer, ptt: true, mimetype: mediaType };
+        } else if (mediaType.startsWith("video/")) {
+          const gifPlayback = sendOptions?.gifPlayback;
+          payload = {
+            video: mediaBuffer,
+            caption: resolvedPayloadText.text || undefined,
+            mimetype: mediaType,
+            ...(gifPlayback ? { gifPlayback: true } : {}),
+          };
+        } else {
+          const fileName = resolveWhatsAppDocumentFileName({
+            fileName: sendOptions?.fileName,
+            mimetype: mediaType,
+          });
+          payload = {
+            document: mediaBuffer,
+            fileName,
+            caption: resolvedPayloadText.text || undefined,
+            mimetype: mediaType,
+          };
+        }
+      } else {
+        payload = { text: resolvedPayloadText.text };
+      }
+      payload = addWhatsAppOutboundMentionsToContent(payload, resolvedPayloadText.mentionedJids);
+      const quotedOpts = buildQuotedMessageOptions({
+        messageId: sendOptions?.quotedMessageKey?.id,
+        remoteJid: sendOptions?.quotedMessageKey?.remoteJid,
+        fromMe: sendOptions?.quotedMessageKey?.fromMe,
+        participant: sendOptions?.quotedMessageKey?.participant,
+        messageText: sendOptions?.quotedMessageKey?.messageText,
+      });
+      const result = quotedOpts
+        ? await params.sock.sendMessage(jid, payload, quotedOpts)
+        : await params.sock.sendMessage(jid, payload);
+      const results = [normalizeWhatsAppSendResult(result, mediaBuffer ? "media" : "text")];
+      if (shouldSendAudioText) {
+        const resolvedAudioText = await resolveMentions(jid, text);
+        const textPayload = addWhatsAppOutboundMentionsToContent(
+          { text: resolvedAudioText.text },
+          resolvedAudioText.mentionedJids,
+        );
+        const textResult = quotedOpts
+          ? await params.sock.sendMessage(jid, textPayload, quotedOpts)
+          : await params.sock.sendMessage(jid, textPayload);
+        results.push(normalizeWhatsAppSendResult(textResult, "text"));
+      }
+      const accountId = sendOptions?.accountId ?? params.defaultAccountId;
+      recordWhatsAppOutbound(accountId);
+      return combineWhatsAppSendResults(mediaBuffer ? "media" : "text", results);
+    },
+    sendPoll: async (
+      to: string,
+      poll: { question: string; options: string[]; maxSelections?: number },
+    ): Promise<WhatsAppSendResult> => {
+      const jid = resolveOutboundJid(to);
+      const result = await params.sock.sendMessage(jid, {
+        poll: {
+          name: poll.question,
+          values: poll.options,
+          selectableCount: poll.maxSelections ?? 1,
+        },
+      } as AnyMessageContent);
+      recordWhatsAppOutbound(params.defaultAccountId);
+      return normalizeWhatsAppSendResult(result, "poll");
+    },
+    sendReaction: async (
+      chatJid: string,
+      messageId: string,
+      emoji: string,
+      fromMe: boolean,
+      participant?: string,
+    ): Promise<WhatsAppSendResult> => {
+      // chatJid is typically already a JID (group or DM); pass through
+      // unchanged. The participant is a sender id and stays PN-shaped to match
+      // how the existing inbound flow stores it.
+      const jid = toWhatsappJid(chatJid);
+      const result = await params.sock.sendMessage(jid, {
+        react: {
+          text: emoji,
+          key: {
+            remoteJid: jid,
+            id: messageId,
+            fromMe,
+            participant: participant ? toWhatsappJid(participant) : undefined,
+          },
+        },
+      } as AnyMessageContent);
+      return normalizeWhatsAppSendResult(result, "reaction");
+    },
+    sendComposingTo: async (to: string): Promise<void> => {
+      const jid = resolveOutboundJid(to);
+      if (isWhatsAppNewsletterJid(jid)) {
+        return;
+      }
+      await params.sock.sendPresenceUpdate("composing", jid);
+    },
+  } as const;
+}

package/src/inbound/send-result.ts

@@ -0,0 +1,109 @@
+import type { WAMessage, WAMessageKey } from "baileys";
+import {
+  createMessageReceiptFromOutboundResults,
+  listMessageReceiptPlatformIds,
+  type MessageReceipt,
+  type MessageReceiptPartKind,
+  type MessageReceiptSourceResult,
+} from "autobot/plugin-sdk/channel-message";
+
+export type WhatsAppSendKind = "media" | "poll" | "reaction" | "text";
+
+type WhatsAppSendKey = Omit<
+  Pick<WAMessageKey, "fromMe" | "id" | "participant" | "remoteJid">,
+  "id"
+> & {
+  id: string;
+};
+
+export type WhatsAppSendResult = {
+  kind: WhatsAppSendKind;
+  messageId: string;
+  receipt?: MessageReceipt;
+  keys: WhatsAppSendKey[];
+  providerAccepted: boolean;
+};
+
+function resolveWhatsAppReceiptKind(kind: WhatsAppSendKind): MessageReceiptPartKind {
+  if (kind === "media" || kind === "text") {
+    return kind;
+  }
+  return "unknown";
+}
+
+function toReceiptSourceResult(key: WhatsAppSendKey): MessageReceiptSourceResult {
+  return {
+    channel: "whatsapp",
+    messageId: key.id,
+    ...(key.remoteJid ? { toJid: key.remoteJid } : {}),
+    meta: {
+      fromMe: key.fromMe,
+      participant: key.participant,
+    },
+  };
+}
+
+function createWhatsAppSendReceipt(
+  kind: WhatsAppSendKind,
+  keys: readonly WhatsAppSendKey[],
+): MessageReceipt {
+  return createMessageReceiptFromOutboundResults({
+    kind: resolveWhatsAppReceiptKind(kind),
+    results: keys.map(toReceiptSourceResult),
+  });
+}
+
+function normalizeKey(key: WAMessageKey | undefined): WhatsAppSendKey | undefined {
+  const id = typeof key?.id === "string" ? key.id.trim() : "";
+  if (!id) {
+    return undefined;
+  }
+  return {
+    id,
+    remoteJid: key?.remoteJid,
+    fromMe: key?.fromMe,
+    participant: key?.participant,
+  };
+}
+
+export function normalizeWhatsAppSendResult(
+  result: WAMessage | undefined,
+  kind: WhatsAppSendKind,
+): WhatsAppSendResult {
+  const key = normalizeKey(result?.key);
+  const messageId = key?.id ?? "unknown";
+  return {
+    kind,
+    messageId,
+    receipt: createWhatsAppSendReceipt(kind, key ? [key] : []),
+    keys: key ? [key] : [],
+    providerAccepted: Boolean(key),
+  };
+}
+
+export function combineWhatsAppSendResults(
+  kind: WhatsAppSendKind,
+  results: readonly WhatsAppSendResult[],
+): WhatsAppSendResult {
+  const messageIds = [...new Set(results.flatMap(listWhatsAppSendResultMessageIds))];
+  const keys = results.flatMap((result) => result.keys);
+  return {
+    kind,
+    messageId: messageIds[0] ?? "unknown",
+    receipt: createWhatsAppSendReceipt(kind, keys),
+    keys,
+    providerAccepted: results.some((result) => result.providerAccepted),
+  };
+}
+
+export function listWhatsAppSendResultMessageIds(result: WhatsAppSendResult): string[] {
+  const receiptIds = result.receipt ? listMessageReceiptPlatformIds(result.receipt) : [];
+  if (receiptIds.length > 0) {
+    return receiptIds;
+  }
+  const keyIds = result.keys.map((key) => key.id.trim()).filter(Boolean);
+  if (keyIds.length > 0) {
+    return [...new Set(keyIds)];
+  }
+  return [];
+}

package/src/inbound/types.ts

@@ -0,0 +1,107 @@
+import type { AnyMessageContent, MiscMessageGenerationOptions } from "baileys";
+import type { NormalizedLocation } from "autobot/plugin-sdk/channel-inbound";
+import type { PollInput } from "autobot/plugin-sdk/poll-runtime";
+import type { WhatsAppIdentity, WhatsAppReplyContext, WhatsAppSelfIdentity } from "../identity.js";
+import type { WhatsAppSendResult } from "./send-result.js";
+
+export type WebListenerCloseReason = {
+  status?: number;
+  isLoggedOut: boolean;
+  error?: unknown;
+};
+
+export type ActiveWebSendOptions = {
+  quotedMessageKey?: {
+    id: string;
+    remoteJid: string;
+    fromMe: boolean;
+    participant?: string;
+    messageText?: string;
+  };
+  gifPlayback?: boolean;
+  accountId?: string;
+  fileName?: string;
+  asDocument?: boolean;
+};
+
+export type ActiveWebListener = {
+  sendMessage: (
+    to: string,
+    text: string,
+    mediaBuffer?: Buffer,
+    mediaType?: string,
+    options?: ActiveWebSendOptions,
+  ) => Promise<WhatsAppSendResult>;
+  sendPoll: (to: string, poll: PollInput) => Promise<WhatsAppSendResult>;
+  sendReaction: (
+    chatJid: string,
+    messageId: string,
+    emoji: string,
+    fromMe: boolean,
+    participant?: string,
+  ) => Promise<WhatsAppSendResult>;
+  sendComposingTo: (to: string) => Promise<void>;
+  close?: () => Promise<void>;
+};
+
+export type WhatsAppStructuredContactContext = {
+  kind: "contact" | "contacts";
+  total: number;
+  contacts: Array<{
+    name?: string;
+    phones?: string[];
+  }>;
+};
+
+export type WebInboundMessage = {
+  id?: string;
+  from: string; // conversation id: E.164 for direct chats, group JID for groups
+  conversationId: string; // alias for clarity (same as from)
+  to: string;
+  accountId: string;
+  /** Set by the real inbound monitor after access-control / pairing checks pass. */
+  accessControlPassed?: boolean;
+  body: string;
+  pushName?: string;
+  timestamp?: number;
+  chatType: "direct" | "group";
+  chatId: string;
+  sender?: WhatsAppIdentity;
+  senderJid?: string;
+  senderE164?: string;
+  senderName?: string;
+  replyTo?: WhatsAppReplyContext;
+  replyToId?: string;
+  replyToBody?: string;
+  replyToSender?: string;
+  replyToSenderJid?: string;
+  replyToSenderE164?: string;
+  groupSubject?: string;
+  groupParticipants?: string[];
+  mentions?: string[];
+  mentionedJids?: string[];
+  self?: WhatsAppSelfIdentity;
+  selfJid?: string | null;
+  selfLid?: string | null;
+  selfE164?: string | null;
+  fromMe?: boolean;
+  location?: NormalizedLocation;
+  sendComposing: () => Promise<void>;
+  reply: (text: string, options?: MiscMessageGenerationOptions) => Promise<WhatsAppSendResult>;
+  sendMedia: (
+    payload: AnyMessageContent,
+    options?: MiscMessageGenerationOptions,
+  ) => Promise<WhatsAppSendResult>;
+  mediaPath?: string;
+  mediaType?: string;
+  mediaFileName?: string;
+  mediaUrl?: string;
+  untrustedStructuredContext?: Array<{
+    label: string;
+    source?: string;
+    type?: string;
+    payload: unknown;
+  }>;
+  wasMentioned?: boolean;
+  isBatched?: boolean;
+};