@cohortapp/agent-sdk 2.3.0

package/lib/channels/whatsapp/adapter-baileys.mjs

@@ -0,0 +1,587 @@
+/**
+ * Maestro — WhatsApp (Baileys) channel adapter
+ *
+ * Baileys is the de facto open-source WhatsApp Web reverse-engineering
+ * library used by openclaw's `/extensions/whatsapp/`. It supports
+ * everything Twilio's API does (text, image, document) plus the
+ * features Twilio's API can't reach because they're WhatsApp-Web-only:
+ *   - Voice notes (PTT) — both inbound and outbound
+ *   - Quoted-message threading (replies in chat)
+ *   - Reactions
+ *   - Group chats with full member roster
+ *   - Read receipts
+ *   - Typing indicators
+ *
+ * Trade-offs vs. Twilio:
+ *   + Free (no per-message Twilio fee)
+ *   + Voice notes work natively
+ *   + Group chats and quoted-reply threading
+ *   - Requires QR-code login from a real WhatsApp account (no Business API)
+ *   - Banned by WhatsApp's ToS for production business use — use only
+ *     for personal-account scenarios (e.g. a sole-proprietor agent
+ *     speaking from the owner's account)
+ *   - Auth state lives on disk; lose it and you re-scan the QR
+ *
+ * This adapter dynamically imports `baileys` so the framework doesn't
+ * force the dependency on every install. Operators who opt in add
+ * `baileys` to their agent's package.json:
+ *
+ *   npm i baileys @whiskeysockets/baileys
+ *
+ * Voice note pipeline:
+ *   inbound voice note → buffer ogg/opus
+ *                      → Whisper / gpt-realtime-whisper transcript
+ *                      → emit MessageEvent with .attachments + .text
+ *   outbound voice note → caller passes attachment {type: "voice_note", buffer}
+ *                      → adapter encodes to ogg/opus + sends as PTT
+ *
+ * WS2 hardening (task #30): this adapter now extends BaseAdapter so it inherits
+ * the ONE shared outbound send-gate (banned-phrase / AI-disclosure / barrier
+ * screening before every send), the bounded-backoff reconnect SUPERVISOR (a
+ * dropped socket reconnects instead of the old one-shot setTimeout restart, and
+ * a dead channel turns healthCheck() red), and the ownId / peerAgentIds
+ * bot-loop guard. Subclasses implement only the platform hooks
+ * `_connect/_toEvent/_send/_react/_setTyping`; baileys is still dynamically
+ * imported. WhatsApp's typing indicator is presence-based ("composing"/"paused")
+ * rather than the base's per-tick `_setTyping`, so this adapter overrides the
+ * heartbeat methods to drive `sock.sendPresenceUpdate` directly.
+ *
+ * @module lib/channels/whatsapp/adapter-baileys
+ */
+
+import { join, resolve } from "node:path";
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { CHANNEL_CAPABILITIES } from "../channel.mjs";
+import { definePlatform } from "../contract.mjs";
+import { BaseAdapter } from "../base-adapter.mjs";
+
+const BAILEYS_CAPABILITIES = [
+  CHANNEL_CAPABILITIES.SEND,
+  CHANNEL_CAPABILITIES.REACT,
+  CHANNEL_CAPABILITIES.THREAD,
+  CHANNEL_CAPABILITIES.MEDIA_IMAGE,
+  CHANNEL_CAPABILITIES.MEDIA_AUDIO,
+  CHANNEL_CAPABILITIES.MEDIA_DOCUMENT,
+  CHANNEL_CAPABILITIES.VOICE_NOTE,
+  CHANNEL_CAPABILITIES.GROUP_CHAT,
+  CHANNEL_CAPABILITIES.READ_RECEIPTS,
+  CHANNEL_CAPABILITIES.TYPING_INDICATOR,
+];
+
+/** Presence-refresh cadence for the WhatsApp typing heartbeat (ms). */
+const TYPING_REFRESH_MS = 8000;
+
+let _baileysCache = null;
+async function loadBaileys(agentRoot) {
+  if (_baileysCache) return _baileysCache;
+  // Resolution strategy:
+  //   1. Resolve from the agent's node_modules (baileys is heavy; the
+  //      framework doesn't bundle it — operators install it in the
+  //      agent repo).
+  //   2. Fall back to framework-relative resolution if the agent path
+  //      doesn't have it (e.g. when run in a dev checkout).
+  const candidates = [];
+  if (agentRoot) {
+    candidates.push(`file://${agentRoot}/node_modules/baileys/lib/index.js`);
+    candidates.push(`file://${agentRoot}/node_modules/baileys/lib/index.mjs`);
+    candidates.push(`file://${agentRoot}/node_modules/baileys/index.js`);
+    candidates.push(`file://${agentRoot}/node_modules/@whiskeysockets/baileys/lib/index.js`);
+  }
+  candidates.push("baileys");
+  candidates.push("@whiskeysockets/baileys");
+
+  const errors = [];
+  for (const spec of candidates) {
+    try {
+      const mod = await import(spec);
+      _baileysCache = mod;
+      return mod;
+    } catch (err) {
+      errors.push(`${spec}: ${err.message}`);
+    }
+  }
+  throw new Error(
+    "WhatsApp(Baileys) requires the `baileys` package installed in the agent repo. " +
+      "Run: `npm i baileys` in your agent repo. " +
+      `Tried resolutions:\n  - ${errors.join("\n  - ")}`
+  );
+}
+
+/**
+ * WhatsApp (Baileys) adapter. Extends BaseAdapter so `send()` runs the shared
+ * send-gate before `_send`, `_connect` is wrapped by the reconnect supervisor,
+ * and inbound from this agent / a peer agent is dropped (bot-loop guard).
+ */
+export class BaileysWhatsAppAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts
+   * @param {string} [opts.authDir]
+   * @param {(buf:Buffer, meta:object)=>Promise<string>} [opts.transcribeVoiceNote]
+   * @param {any} [opts.sock]  inject a connected Baileys socket (tests)
+   */
+  constructor(opts = {}) {
+    super({ name: "whatsapp", capabilities: BAILEYS_CAPABILITIES, ...opts });
+    this.transport = "baileys";
+    this.authDir = opts.authDir || join(this.agentRoot, "state/whatsapp/auth");
+    this.transcribe =
+      typeof opts.transcribeVoiceNote === "function" ? opts.transcribeVoiceNote : null;
+
+    /** @type {any} the Baileys WASocket once connected */
+    this._sock = opts.sock || null;
+
+    // Per-jid "composing" presence refresh timers (typing heartbeat). WhatsApp's
+    // typing indicator auto-expires (~25s), so we re-assert "composing" on an
+    // interval while a session is working, then send "paused" on stop. Keyed by
+    // jid so a second start for the same chat doesn't stack timers. This is the
+    // presence-based heartbeat WhatsApp needs in place of the base's per-tick
+    // `_setTyping`, so the heartbeat methods are overridden below.
+    /** @type {Map<string, any>} */
+    this._presenceTimers = new Map();
+  }
+
+  // ── Test seams (no-ops in production; never called on the live path) ──
+  /** @internal inject a fake sock without connecting (tests only). */
+  __setSock(s) { this._sock = s; }
+  /** @internal number of active per-jid typing timers (tests only). */
+  __typingTimerCount() { return this._presenceTimers.size; }
+
+  /** Best-effort presence send; a missing/disconnected sock just no-ops. */
+  _sendPresence(state, jid) {
+    try {
+      const sock = this._sock;
+      if (sock && typeof sock.sendPresenceUpdate === "function") {
+        // sendPresenceUpdate may be async; we don't await (fire-and-forget) and
+        // swallow any rejection so a dropped socket never surfaces here.
+        Promise.resolve(sock.sendPresenceUpdate(state, jid)).catch(() => {});
+      }
+    } catch { /* fail-open: disconnected/absent sock */ }
+  }
+
+  /** Resolve a jid from a SessionSource ({chatId}) or a bare chatId string. */
+  _jidFromSource(source) {
+    const raw = source && typeof source === "object" ? source.chatId : source;
+    if (!raw) return "";
+    try { return normaliseJid(String(raw)); } catch { return ""; }
+  }
+
+  // -- connect: open the Baileys socket, wire its events to the supervisor ----
+
+  async _connect({ onRaw, signal }) {
+    mkdirSync(this.authDir, { recursive: true });
+
+    if (!this._sock) {
+      const baileys = await loadBaileys(this.agentRoot);
+      const makeSocket = baileys.makeWASocket || baileys.default;
+      const useMultiFileAuthState = baileys.useMultiFileAuthState;
+      const fetchLatestBaileysVersion = baileys.fetchLatestBaileysVersion;
+
+      const { state, saveCreds } = await useMultiFileAuthState(this.authDir);
+      const { version } = fetchLatestBaileysVersion
+        ? await fetchLatestBaileysVersion()
+        : { version: undefined };
+
+      this._sock = makeSocket({
+        version,
+        auth: state,
+        printQRInTerminal: false, // we surface the QR code via the event handler
+        // Some Baileys versions accept `logger`; we pass a no-op-ish to silence noise.
+        logger: {
+          level: "warn", info: () => {}, warn: () => {}, error: (...a) => this.log("error", a.join(" ")),
+          debug: () => {}, trace: () => {}, child: () => ({ level: "warn", info: () => {}, warn: () => {}, error: () => {}, debug: () => {}, trace: () => {}, child: () => this }),
+        },
+      });
+
+      this._sock.ev.on("creds.update", saveCreds);
+    }
+    const sock = this._sock;
+    const DisconnectReason = (await loadBaileysDisconnectReason(this.agentRoot)) || {};
+
+    sock.ev.on("connection.update", (update) => {
+      const { connection, lastDisconnect, qr } = update;
+      if (qr) {
+        // Persist the QR string so the operator can render it elsewhere
+        // (terminal qrcode-terminal, web UI, etc.) without forcing us
+        // to pull a QR-rendering dep into the framework.
+        try { writeFileSync(join(this.authDir, "pending-qr.txt"), qr); } catch { /* */ }
+        this.log("info", `QR code pending — scan it. Saved to ${join(this.authDir, "pending-qr.txt")}`);
+      }
+      if (connection === "open") {
+        this.log("info", "WhatsApp (Baileys) connected");
+      } else if (connection === "close") {
+        const reason = lastDisconnect?.error?.output?.statusCode;
+        // A logged-out socket can't be recovered by reconnecting (the auth state
+        // is gone) — let the supervisor give up rather than thrash. Every other
+        // drop is reported to the reconnect supervisor, which owns the bounded
+        // backoff (replacing the old one-shot setTimeout(start, 5000) that died
+        // permanently after a single swallowed failure — gaps P0-6).
+        const loggedOut = reason === (DisconnectReason.loggedOut || 401);
+        this.log("warn", `connection closed (reason=${reason}); loggedOut=${loggedOut}`);
+        if (!loggedOut && !this._stopping && !signal?.aborted) {
+          this.notifyConnectionDown(`whatsapp-close:${reason ?? "?"}`);
+        }
+      }
+    });
+
+    sock.ev.on("messages.upsert", async ({ messages, type }) => {
+      if (type !== "notify") return;
+      for (const m of messages) {
+        if (m.key?.fromMe) continue;
+        try {
+          const raw = await normaliseInbound(m, { sock, transcribe: this.transcribe, agentRoot: this.agentRoot });
+          if (raw) onRaw(raw);
+        } catch (err) {
+          this.log("error", `failed to normalise inbound: ${err.message}`);
+        }
+      }
+    });
+
+    if (signal) signal.addEventListener?.("abort", () => { try { sock?.end?.(undefined); } catch { /* */ } });
+  }
+
+  // -- translate: normalised inbound → MessageEvent --------------------------
+  //
+  // normaliseInbound already produces a MessageEvent-shaped object (with a
+  // `source` descriptor) so the platform factory's old start-wrapper is no
+  // longer needed; _toEvent simply forwards it, with a defensive null check.
+
+  _toEvent(raw) {
+    if (!raw || typeof raw !== "object") return null;
+    return raw;
+  }
+
+  // -- outbound transport (gated by BaseAdapter.send before this runs) --------
+
+  async _send(out) {
+    const sock = this._sock;
+    if (!sock) throw new Error("WhatsApp(Baileys) not connected — call start() first");
+    const to = out?.to ?? out?.source?.chatId;
+    if (!to) throw new Error("WhatsApp._send: `to` (jid like '9715...@s.whatsapp.net' or E.164) required");
+    const jid = normaliseJid(to);
+
+    // Quoted reply
+    const threadRef = out.thread_ref ?? out.source?.threadRef;
+    const quoted = threadRef ? { key: parseQuotedRef(threadRef) } : undefined;
+
+    // Voice note path
+    if (out.attachments?.length === 1 && out.attachments[0].type === "voice_note") {
+      const att = out.attachments[0];
+      const audio = att.buffer || (att.url ? await fetchUrl(att.url) : null);
+      if (!audio) throw new Error("voice_note attachment requires buffer or url");
+      const result = await sock.sendMessage(jid, {
+        audio,
+        mimetype: att.mime || "audio/ogg; codecs=opus",
+        ptt: true,
+      }, quoted);
+      return { ok: true, message_id: result?.key?.id || "", raw: result };
+    }
+
+    // Media attachments
+    if (out.attachments?.length) {
+      // Send the first attachment with a caption from out.text; for
+      // multi-attachment payloads, send them sequentially (caller
+      // gets the id of the last send).
+      let last;
+      for (let i = 0; i < out.attachments.length; i++) {
+        const att = out.attachments[i];
+        const buffer = att.buffer || (att.url ? await fetchUrl(att.url) : null);
+        if (!buffer) throw new Error(`attachment ${i} requires buffer or url`);
+        const payload = mediaPayload(att, buffer, i === 0 ? out.text : undefined);
+        last = await sock.sendMessage(jid, payload, quoted);
+      }
+      return { ok: true, message_id: last?.key?.id || "", raw: last };
+    }
+
+    // Plain text
+    const result = await sock.sendMessage(jid, { text: out.text || "" }, quoted);
+    return { ok: true, message_id: result?.key?.id || "", raw: result };
+  }
+
+  async _react(out) {
+    const sock = this._sock;
+    if (!sock) throw new Error("WhatsApp(Baileys) not connected");
+    const ref = parseQuotedRef(out.messageRef);
+    await sock.sendMessage(ref.remoteJid, {
+      react: { text: out.emoji, key: ref },
+    });
+    return { ok: true };
+  }
+
+  // -- typing: presence-based heartbeat (overrides the base per-tick model) ---
+
+  /**
+   * Start a presence-based "typing…" heartbeat for a conversation. Sends
+   * "composing" immediately, then refreshes it on an unref'd interval so the
+   * indicator doesn't lapse mid-session. Idempotent per jid. Fail-open: a
+   * missing/disconnected sock makes this a no-op.
+   * @param {{chatId?:string}|string} source
+   * @returns {any} the (existing or new) timer handle
+   */
+  startTypingHeartbeat(source) {
+    try {
+      const jid = this._jidFromSource(source);
+      if (!jid) return null;
+      this._sendPresence("composing", jid);
+      const existing = this._presenceTimers.get(jid);
+      if (existing) return existing; // already heart-beating this jid — don't stack
+      const timer = this._setInterval(() => this._sendPresence("composing", jid), TYPING_REFRESH_MS);
+      if (timer && typeof timer.unref === "function") timer.unref();
+      this._presenceTimers.set(jid, timer);
+      return timer;
+    } catch {
+      return null; // fail-open
+    }
+  }
+
+  /**
+   * Stop the heartbeat for a conversation: clear its refresh timer and send a
+   * best-effort "paused" presence. Fail-open; stopping an unknown jid is a
+   * clean no-op.
+   * @param {{chatId?:string}|string} source
+   */
+  stopTypingHeartbeat(source) {
+    try {
+      const jid = this._jidFromSource(source);
+      if (!jid) return;
+      const timer = this._presenceTimers.get(jid);
+      if (timer) {
+        this._clearInterval(timer);
+        this._presenceTimers.delete(jid);
+      }
+      this._sendPresence("paused", jid);
+    } catch { /* fail-open */ }
+  }
+
+  /** Clear every presence heartbeat (called from stop()). */
+  stopAllTyping() {
+    for (const t of this._presenceTimers.values()) { try { this._clearInterval(t); } catch { /* */ } }
+    this._presenceTimers.clear();
+  }
+
+  /**
+   * Base hook so any base-class caller of `_setTyping` still drives the right
+   * WhatsApp presence (the heartbeat methods above are the live path).
+   */
+  async _setTyping(source, on) {
+    const jid = this._jidFromSource(source);
+    if (!jid) return;
+    this._sendPresence(on ? "composing" : "paused", jid);
+  }
+
+  // -- health / lifecycle ----------------------------------------------------
+
+  async healthCheck() {
+    // Prefer the supervisor's view when supervised (a dead channel reports RED);
+    // otherwise fall back to the socket-identity probe.
+    const base = await super.healthCheck();
+    const connected = !!this._sock?.user;
+    if (this._superviseEnabled && this._supervisor) {
+      return {
+        ...base,
+        detail: connected ? `connected as ${this._sock.user.id}` : base.detail,
+      };
+    }
+    return { ok: connected, detail: connected ? `connected as ${this._sock.user.id}` : "not connected" };
+  }
+
+  async stop() {
+    await super.stop();
+    this.stopAllTyping();
+    try { this._sock?.end?.(undefined); } catch { /* */ }
+    this._sock = null;
+  }
+}
+
+/**
+ * Factory matching the channel/platform contract. Returns a BaseAdapter
+ * subclass instance; the daemon/registry call `.start({onInbound,signal})`,
+ * `.send()`, `.react()`, `.healthCheck()`, `.stop()`, and the typing-registry
+ * drives `.startTypingHeartbeat`/`.stopTypingHeartbeat`.
+ */
+export function createBaileysWhatsAppChannel(opts = {}) {
+  return new BaileysWhatsAppAdapter(opts);
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────────
+
+/** Best-effort import of Baileys' DisconnectReason map (for loggedOut). */
+async function loadBaileysDisconnectReason(agentRoot) {
+  try {
+    const baileys = await loadBaileys(agentRoot);
+    return baileys.DisconnectReason || null;
+  } catch {
+    return null;
+  }
+}
+
+function mediaPayload(att, buffer, caption) {
+  switch (att.type) {
+    case "image":
+      return { image: buffer, mimetype: att.mime || "image/jpeg", caption };
+    case "video":
+      return { video: buffer, mimetype: att.mime || "video/mp4", caption };
+    case "audio":
+      return { audio: buffer, mimetype: att.mime || "audio/mpeg", ptt: false };
+    case "document":
+      return { document: buffer, mimetype: att.mime || "application/pdf", fileName: att.filename, caption };
+    default:
+      return { document: buffer, mimetype: att.mime || "application/octet-stream", fileName: att.filename, caption };
+  }
+}
+
+function normaliseJid(to) {
+  if (String(to).includes("@")) return String(to);
+  const digits = String(to).replace(/[^\d]/g, "");
+  return `${digits}@s.whatsapp.net`;
+}
+
+function parseQuotedRef(ref) {
+  // Accept either an object {remoteJid, id, fromMe} or a serialised
+  // string "remoteJid:id:fromMe".
+  if (typeof ref === "object" && ref?.id) return ref;
+  const [remoteJid, id, fromMe] = String(ref).split(":");
+  return { remoteJid, id, fromMe: fromMe === "true" };
+}
+
+async function normaliseInbound(m, { sock, transcribe, agentRoot }) {
+  const channel = "whatsapp";
+  const remoteJid = m.key.remoteJid;
+  const id = m.key.id;
+  const isGroup = remoteJid?.endsWith("@g.us");
+  const senderJid = isGroup ? m.key.participant : remoteJid;
+  const ts = m.messageTimestamp;
+
+  // Identify message body across the many Baileys message shapes.
+  let text = "";
+  const attachments = [];
+
+  const inner =
+    m.message?.conversation ??
+    m.message?.extendedTextMessage?.text ??
+    null;
+  if (typeof inner === "string") text = inner;
+
+  // Quoted message reference (thread_id)
+  let thread_id = null;
+  const ctx = m.message?.extendedTextMessage?.contextInfo;
+  if (ctx?.stanzaId) {
+    thread_id = `${ctx.remoteJid || remoteJid}:${ctx.stanzaId}:${!!ctx.fromMe}`;
+  }
+
+  let kind = "message";
+
+  // Voice note → transcribe
+  if (m.message?.audioMessage?.ptt) {
+    kind = "voice_note";
+    const buffer = await downloadMedia(sock, m, "audio", agentRoot);
+    let transcript = "";
+    if (transcribe && buffer) {
+      try { transcript = await transcribe(buffer, { mime: m.message.audioMessage.mimetype }); }
+      catch (err) { transcript = `(transcription failed: ${err.message})`; }
+    }
+    attachments.push({
+      type: "voice_note",
+      mime: m.message.audioMessage.mimetype || "audio/ogg; codecs=opus",
+      size_bytes: buffer?.length || 0,
+      transcript,
+    });
+    if (transcript) text = transcript; // surface as the message body
+  }
+  // Image, document, etc.
+  for (const [key, kindName] of [
+    ["imageMessage", "image"],
+    ["videoMessage", "video"],
+    ["documentMessage", "document"],
+    ["audioMessage", "audio"],
+  ]) {
+    if (m.message?.[key]) {
+      if (key === "audioMessage" && m.message.audioMessage.ptt) continue; // handled above
+      const mime = m.message[key].mimetype || null;
+      const filename = m.message[key].fileName || null;
+      attachments.push({ type: kindName, mime, filename });
+      const caption = m.message[key].caption;
+      if (caption && !text) text = caption;
+    }
+  }
+
+  const toId = remoteJid;
+  const chatId = String(toId || senderJid || "");
+  return {
+    channel,
+    message_id: id,
+    thread_id,
+    in_reply_to: ctx?.stanzaId || null,
+    from: { id: senderJid, phone: jidToPhone(senderJid) },
+    to: { id: remoteJid },
+    text,
+    attachments,
+    kind,
+    timestamp: typeof ts === "number" ? new Date(ts * 1000).toISOString() : new Date().toISOString(),
+    raw: m,
+    // Durable source descriptor so the inbox-item seam + typing registry have
+    // the conversation descriptor (previously stamped by the platform wrapper).
+    source: {
+      channel: "whatsapp",
+      chatId,
+      threadRef: thread_id || undefined,
+      userScope: chatId.endsWith("@g.us") ? "group" : "dm",
+      peerId: senderJid,
+    },
+  };
+}
+
+async function downloadMedia(sock, m, type, agentRoot) {
+  try {
+    if (typeof sock.downloadMediaMessage === "function") {
+      return await sock.downloadMediaMessage(m);
+    }
+    // Newer Baileys: helper function exported on module
+    const baileys = await loadBaileys(agentRoot);
+    if (typeof baileys.downloadMediaMessage === "function") {
+      return await baileys.downloadMediaMessage(m, "buffer", {});
+    }
+  } catch { /* */ }
+  return null;
+}
+
+function jidToPhone(jid) {
+  if (!jid) return null;
+  return "+" + String(jid).split("@")[0].split(":")[0];
+}
+
+async function fetchUrl(url) {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`fetch ${url} failed: ${res.status}`);
+  return Buffer.from(await res.arrayBuffer());
+}
+
+/**
+ * Platform factory for the daemon's generic channel-bus loop. Gated by
+ * config/whatsapp.yaml; only handles the Baileys transport (Twilio WhatsApp
+ * uses its own webhook path, not the bus). Throws a clear skip when the config
+ * selects a different transport so the loop logs and moves on.
+ *
+ * The adapter itself now stamps each inbound MessageEvent with a `source`
+ * descriptor (in normaliseInbound), and BaseAdapter.start owns the connect
+ * supervisor + send-gate + bot-loop guard, so the old start-wrapper that
+ * re-stamped `source` / forced `kind` is no longer needed.
+ */
+function createWhatsAppPlatform(opts = {}) {
+  const agentRoot = resolve(opts.agentRoot || process.env.AGENT_ROOT || process.env.AGENT_DIR || process.cwd());
+  const cfgPath = join(agentRoot, "config/whatsapp.yaml");
+  if (existsSync(cfgPath)) {
+    const body = readFileSync(cfgPath, "utf-8");
+    if (!/^transport:\s*baileys\b/m.test(body)) {
+      throw new Error("whatsapp transport is not baileys — handled outside the channel bus");
+    }
+  }
+  return createBaileysWhatsAppChannel(opts);
+}
+
+definePlatform({
+  name: "whatsapp",
+  gateFile: "config/whatsapp.yaml",
+  factory: createWhatsAppPlatform,
+  capabilities: BAILEYS_CAPABILITIES,
+});
+
+export default createBaileysWhatsAppChannel;