// Whatsapp plugin module implements monitor behavior.

import type { WAMessageKey } from "baileys";

import { resolveAccountEntry } from "openclaw/plugin-sdk/account-core";

import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-runtime";

import { resolveInboundDebounceMs } from "openclaw/plugin-sdk/channel-inbound-debounce";

} from "../connection-controller.js";

import { resolveWhatsAppInboundPolicy } from "../inbound-policy.js";

import { normalizeWebInboundMessage } from "../inbound/message-aliases.js";

import { attachWebInboxToSocket, type WhatsAppGroupMetadataCache } from "../inbound/monitor.js";

import {

attachWebInboxToSocket,

readWhatsAppBaileysCacheEntry,

type WhatsAppBaileysGroupMetadataCache,

type WhatsAppBaileysMessageCache,

type WhatsAppGroupMetadataCache,

} from "../inbound/monitor.js";

import type { WebInboundMessageInput } from "../inbound/types.js";

import {

newConnectionId,

>();

const groupMemberNames = new Map<string, Map<string, string>>();

const groupMetadataCache: WhatsAppGroupMetadataCache = new Map();

const recentMessageKeys: WhatsAppBaileysMessageCache = new Map();

const baileysGroupMetaCache: WhatsAppBaileysGroupMetadataCache = new Map();

const echoTracker = createEchoTracker({ maxItems: 100, logVerbose });

const sleep =

try {

connection = await controller.openConnection({

connectionId,

getMessage: async (key: WAMessageKey) =>

key.id && key.remoteJid

? readWhatsAppBaileysCacheEntry(recentMessageKeys, `${key.remoteJid}:${key.id}`)

: undefined,

cachedGroupMetadata: async (jid: string) => {

const meta = readWhatsAppBaileysCacheEntry(baileysGroupMetaCache, jid);

return meta?.participants?.length ? meta : undefined;

},

createListener: async ({ sock, connection: connectionLocal }) => {

const onMessage = createWebOnMessageHandler({

cfg,

disconnectRetryPolicy: reconnectPolicy,

disconnectRetryAbortSignal: controller.getDisconnectRetryAbortSignal(),

groupMetadataCache,

recentMessageKeys,

baileysGroupMetaCache,

onMessage: async (msg: WebInboundMessageInput) => {

const normalized = normalizeWebInboundMessage(msg);

const inboundAt = Date.now();

// Whatsapp plugin module implements connection controller behavior.

import type { WASocket } from "baileys";

import type { GroupMetadata, WASocket, WAMessageKey, proto } from "baileys";

import { info } from "openclaw/plugin-sdk/runtime-env";

import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";

import {

}) => Promise<ManagedWhatsAppListener>;

onHeartbeat?: (snapshot: WhatsAppConnectionSnapshot) => void;

onWatchdogTimeout?: (snapshot: WhatsAppConnectionSnapshot) => void;

getMessage?: (key: WAMessageKey) => Promise<proto.IMessage | undefined>;

cachedGroupMetadata?: (jid: string) => Promise<GroupMetadata | undefined>;

}): Promise<WhatsAppLiveConnection> {

if (this.current) {

await this.closeCurrentConnection();

sock = await createWaSocket(false, this.verbose, {

authDir: this.authDir,

...this.socketTiming,

...(params.getMessage ? { getMessage: params.getMessage } : {}),

...(params.cachedGroupMetadata ? { cachedGroupMetadata: params.cachedGroupMetadata } : {}),

});

await waitForWaConnection(sock, { timeoutMs: this.socketTiming.connectTimeoutMs });