@gakr-gakr/whatsapp 0.1.0

package/src/auto-reply/reply-resolver.runtime.ts

@@ -0,0 +1 @@
+export { getReplyFromConfig } from "autobot/plugin-sdk/reply-runtime";

package/src/auto-reply/types.ts

@@ -0,0 +1,48 @@
+import type { WebInboundMessage } from "../inbound/types.js";
+import type { ReconnectPolicy } from "../reconnect.js";
+import type { WhatsAppSocketTimingOptions } from "../socket-timing.js";
+
+export type WebChannelHealthState =
+  | "starting"
+  | "healthy"
+  | "stale"
+  | "reconnecting"
+  | "conflict"
+  | "logged-out"
+  | "stopped";
+
+export type WebInboundMsg = WebInboundMessage;
+
+export type WebChannelStatus = {
+  running: boolean;
+  connected: boolean;
+  reconnectAttempts: number;
+  lastConnectedAt?: number | null;
+  lastDisconnect?: {
+    at: number;
+    status?: number;
+    error?: string;
+    loggedOut?: boolean;
+  } | null;
+  lastInboundAt?: number | null;
+  lastMessageAt?: number | null;
+  lastEventAt?: number | null;
+  lastTransportActivityAt?: number | null;
+  lastError?: string | null;
+  healthState?: WebChannelHealthState;
+};
+
+export type WebMonitorTuning = {
+  reconnect?: Partial<ReconnectPolicy>;
+  socketTiming?: WhatsAppSocketTimingOptions;
+  heartbeatSeconds?: number;
+  transportTimeoutMs?: number;
+  messageTimeoutMs?: number;
+  watchdogCheckMs?: number;
+  sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+  statusSink?: (status: WebChannelStatus) => void;
+  /** WhatsApp account id. Default: "default". */
+  accountId?: string;
+  /** Debounce window (ms) for batching rapid consecutive messages from the same sender. */
+  debounceMs?: number;
+};

package/src/auto-reply/util.ts

@@ -0,0 +1,62 @@
+import { normalizeLowercaseStringOrEmpty } from "autobot/plugin-sdk/string-coerce-runtime";
+
+export function elide(text?: string, limit = 400) {
+  if (!text) {
+    return text;
+  }
+  if (text.length <= limit) {
+    return text;
+  }
+  return `${text.slice(0, limit)}… (truncated ${text.length - limit} chars)`;
+}
+
+export function isLikelyWhatsAppCryptoError(reason: unknown) {
+  const formatReason = (value: unknown): string => {
+    if (value == null) {
+      return "";
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (value instanceof Error) {
+      return `${value.message}\n${value.stack ?? ""}`;
+    }
+    if (typeof value === "object") {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        return Object.prototype.toString.call(value);
+      }
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return String(value);
+    }
+    if (typeof value === "bigint") {
+      return String(value);
+    }
+    if (typeof value === "symbol") {
+      return value.description ?? value.toString();
+    }
+    if (typeof value === "function") {
+      return value.name ? `[function ${value.name}]` : "[function]";
+    }
+    return Object.prototype.toString.call(value);
+  };
+  const raw =
+    reason instanceof Error ? `${reason.message}\n${reason.stack ?? ""}` : formatReason(reason);
+  const haystack = normalizeLowercaseStringOrEmpty(raw);
+  const hasAuthError =
+    haystack.includes("unsupported state or unable to authenticate data") ||
+    haystack.includes("bad mac");
+  if (!hasAuthError) {
+    return false;
+  }
+  return (
+    haystack.includes("baileys") ||
+    haystack.includes("noise-handler") ||
+    haystack.includes("aesdecryptgcm")
+  );
+}

package/src/auto-reply.impl.ts

@@ -0,0 +1,6 @@
+export { HEARTBEAT_PROMPT, stripHeartbeatToken } from "autobot/plugin-sdk/reply-runtime";
+export { HEARTBEAT_TOKEN, SILENT_REPLY_TOKEN } from "autobot/plugin-sdk/reply-runtime";
+
+export { DEFAULT_WEB_MEDIA_BYTES } from "./auto-reply/constants.js";
+export { monitorWebChannel } from "./auto-reply/monitor.js";
+export type { WebChannelStatus, WebMonitorTuning } from "./auto-reply/types.js";

package/src/auto-reply.ts

@@ -0,0 +1 @@
+export * from "./auto-reply.impl.js";

package/src/channel-actions.runtime.ts

@@ -0,0 +1,7 @@
+import { createActionGate } from "autobot/plugin-sdk/channel-actions";
+import type { ChannelMessageActionName } from "autobot/plugin-sdk/channel-contract";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+export { listWhatsAppAccountIds, resolveWhatsAppAccount } from "./accounts.js";
+export { resolveWhatsAppReactionLevel } from "./reaction-level.js";
+export { createActionGate, type ChannelMessageActionName, type AutoBotConfig };

package/src/channel-actions.ts

@@ -0,0 +1,85 @@
+import {
+  listWhatsAppAccountIds,
+  resolveWhatsAppAccount,
+  createActionGate,
+  type ChannelMessageActionName,
+  type AutoBotConfig,
+  resolveWhatsAppReactionLevel,
+} from "./channel-actions.runtime.js";
+
+function areWhatsAppAgentReactionsEnabled(params: { cfg: AutoBotConfig; accountId?: string }) {
+  if (!params.cfg.channels?.whatsapp) {
+    return false;
+  }
+  const gate = createActionGate(params.cfg.channels.whatsapp.actions);
+  if (!gate("reactions")) {
+    return false;
+  }
+  return resolveWhatsAppReactionLevel({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  }).agentReactionsEnabled;
+}
+
+function hasAnyWhatsAppAccountWithAgentReactionsEnabled(cfg: AutoBotConfig) {
+  if (!cfg.channels?.whatsapp) {
+    return false;
+  }
+  return listWhatsAppAccountIds(cfg).some((accountId) => {
+    const account = resolveWhatsAppAccount({ cfg, accountId });
+    if (!account.enabled) {
+      return false;
+    }
+    return areWhatsAppAgentReactionsEnabled({
+      cfg,
+      accountId,
+    });
+  });
+}
+
+export function resolveWhatsAppAgentReactionGuidance(params: {
+  cfg: AutoBotConfig;
+  accountId?: string;
+}) {
+  if (!params.cfg.channels?.whatsapp) {
+    return undefined;
+  }
+  const gate = createActionGate(params.cfg.channels.whatsapp.actions);
+  if (!gate("reactions")) {
+    return undefined;
+  }
+  const resolved = resolveWhatsAppReactionLevel({
+    cfg: params.cfg,
+    accountId: params.accountId,
+  });
+  if (!resolved.agentReactionsEnabled) {
+    return undefined;
+  }
+  return resolved.agentReactionGuidance;
+}
+
+export function describeWhatsAppMessageActions(params: {
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+}): { actions: ChannelMessageActionName[] } | null {
+  if (!params.cfg.channels?.whatsapp) {
+    return null;
+  }
+  const gate = createActionGate(params.cfg.channels.whatsapp.actions);
+  const actions = new Set<ChannelMessageActionName>();
+  const canReact =
+    params.accountId != null
+      ? areWhatsAppAgentReactionsEnabled({
+          cfg: params.cfg,
+          accountId: params.accountId ?? undefined,
+        })
+      : hasAnyWhatsAppAccountWithAgentReactionsEnabled(params.cfg);
+  if (canReact) {
+    actions.add("react");
+  }
+  if (gate("polls")) {
+    actions.add("poll");
+  }
+  actions.add("upload-file");
+  return { actions: Array.from(actions) };
+}

package/src/channel-outbound.ts

@@ -0,0 +1,87 @@
+import {
+  createMessageReceiptFromOutboundResults,
+  defineChannelMessageAdapter,
+  type ChannelMessageSendResult,
+} from "autobot/plugin-sdk/channel-message";
+import { chunkText } from "autobot/plugin-sdk/reply-chunking";
+import { createWhatsAppOutboundBase } from "./outbound-base.js";
+import { normalizeWhatsAppPayloadTextPreservingIndentation } from "./outbound-media-contract.js";
+import { resolveWhatsAppOutboundTarget } from "./resolve-outbound-target.js";
+import { getWhatsAppRuntime } from "./runtime.js";
+import { sendMessageWhatsApp, sendPollWhatsApp } from "./send.js";
+
+export function normalizeWhatsAppChannelPayloadText(text: string | undefined): string {
+  return normalizeWhatsAppPayloadTextPreservingIndentation(text);
+}
+
+function normalizeWhatsAppChannelSendText(text: string | undefined): string {
+  const normalized = normalizeWhatsAppChannelPayloadText(text);
+  return normalized.trim() ? normalized : "";
+}
+
+export const whatsappChannelOutbound = {
+  ...createWhatsAppOutboundBase({
+    chunker: chunkText,
+    sendMessageWhatsApp: async (to, text, options) =>
+      await sendMessageWhatsApp(to, text, {
+        ...options,
+        preserveLeadingWhitespace: true,
+      }),
+    sendPollWhatsApp,
+    shouldLogVerbose: () => getWhatsAppRuntime().logging.shouldLogVerbose(),
+    resolveTarget: ({ to, allowFrom, mode }) =>
+      resolveWhatsAppOutboundTarget({ to, allowFrom, mode }),
+    normalizeText: normalizeWhatsAppChannelSendText,
+  }),
+  sendTextOnlyErrorPayloads: true,
+  normalizePayload: ({ payload }: { payload: { text?: string } }) => ({
+    ...payload,
+    text: normalizeWhatsAppChannelPayloadText(payload.text),
+  }),
+};
+
+function toWhatsAppMessageSendResult(
+  result: Awaited<ReturnType<NonNullable<typeof whatsappChannelOutbound.sendText>>>,
+  replyToId?: string | null,
+): ChannelMessageSendResult {
+  const source = result as typeof result & { toJid?: string };
+  const receipt =
+    result.receipt ??
+    createMessageReceiptFromOutboundResults({
+      results: result.messageId
+        ? [
+            {
+              channel: "whatsapp",
+              messageId: result.messageId,
+              toJid: source.toJid,
+            },
+          ]
+        : [],
+      kind: "text",
+      ...(replyToId ? { replyToId } : {}),
+    });
+  return {
+    messageId: result.messageId || receipt.primaryPlatformMessageId,
+    receipt,
+  };
+}
+
+export const whatsappMessageAdapter = defineChannelMessageAdapter({
+  id: "whatsapp",
+  durableFinal: {
+    capabilities: {
+      text: true,
+      replyTo: true,
+      messageSendingHooks: true,
+    },
+  },
+  send: {
+    text: async (ctx) =>
+      toWhatsAppMessageSendResult(
+        await whatsappChannelOutbound.sendText!({
+          ...ctx,
+        }),
+        ctx.replyToId,
+      ),
+  },
+});

package/src/channel-react-action.runtime.ts

@@ -0,0 +1,10 @@
+import { readStringOrNumberParam, readStringParam } from "autobot/plugin-sdk/channel-actions";
+import type { AutoBotConfig } from "autobot/plugin-sdk/config-contracts";
+
+export { resolveReactionMessageId } from "autobot/plugin-sdk/channel-actions";
+export { handleWhatsAppAction } from "./action-runtime.js";
+export { resolveAuthorizedWhatsAppOutboundTarget } from "./action-runtime-target-auth.js";
+export { resolveWhatsAppAccount, resolveWhatsAppMediaMaxBytes } from "./accounts.js";
+export { isWhatsAppGroupJid, normalizeWhatsAppTarget } from "./normalize.js";
+export { sendMessageWhatsApp } from "./send.js";
+export { readStringOrNumberParam, readStringParam, type AutoBotConfig };

package/src/channel-react-action.ts

@@ -0,0 +1,247 @@
+import { jsonResult } from "autobot/plugin-sdk/channel-actions";
+import {
+  isWhatsAppGroupJid,
+  resolveAuthorizedWhatsAppOutboundTarget,
+  resolveWhatsAppAccount,
+  resolveWhatsAppMediaMaxBytes,
+  resolveReactionMessageId,
+  handleWhatsAppAction,
+  normalizeWhatsAppTarget,
+  readStringOrNumberParam,
+  readStringParam,
+  sendMessageWhatsApp,
+  type AutoBotConfig,
+} from "./channel-react-action.runtime.js";
+
+const WHATSAPP_CHANNEL = "whatsapp" as const;
+
+type WhatsAppMessageActionParams = {
+  action: string;
+  params: Record<string, unknown>;
+  cfg: AutoBotConfig;
+  accountId?: string | null;
+  requesterSenderId?: string | null;
+  mediaAccess?: {
+    localRoots?: readonly string[];
+    readFile?: (filePath: string) => Promise<Buffer>;
+  };
+  mediaLocalRoots?: readonly string[];
+  mediaReadFile?: (filePath: string) => Promise<Buffer>;
+  toolContext?: {
+    currentChannelId?: string | null;
+    currentChannelProvider?: string | null;
+    currentMessageId?: string | number | null;
+  };
+};
+
+function readUploadFileMediaSource(args: Record<string, unknown>): string | undefined {
+  return (
+    readStringParam(args, "media", { trim: false }) ??
+    readStringParam(args, "mediaUrl", { trim: false }) ??
+    readStringParam(args, "filePath", { trim: false }) ??
+    readStringParam(args, "path", { trim: false }) ??
+    readStringParam(args, "fileUrl", { trim: false })
+  );
+}
+
+function readUploadFileCaptionText(args: Record<string, unknown>): string {
+  return (
+    readStringParam(args, "message", { allowEmpty: true }) ??
+    readStringParam(args, "content", { allowEmpty: true }) ??
+    readStringParam(args, "caption", { allowEmpty: true }) ??
+    ""
+  );
+}
+
+function readBooleanParam(args: Record<string, unknown>, key: string): boolean | undefined {
+  const value = args[key];
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value !== "string") {
+    return undefined;
+  }
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true") {
+    return true;
+  }
+  if (normalized === "false") {
+    return false;
+  }
+  return undefined;
+}
+
+function hasUploadFileBufferPayload(args: Record<string, unknown>): boolean {
+  return readStringParam(args, "buffer", { trim: false }) !== undefined;
+}
+
+function extractBase64Payload(encoded: string): string {
+  const match = /^data:[^;]+;base64,(.*)$/i.exec(encoded.trim());
+  return match ? match[1] : encoded;
+}
+
+function estimateBase64DecodedBytes(encoded: string): number {
+  const compact = extractBase64Payload(encoded).replace(/\s/g, "");
+  if (!compact) {
+    return 0;
+  }
+  const padding = compact.endsWith("==") ? 2 : compact.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor((compact.length * 3) / 4) - padding);
+}
+
+function decodeUploadFileMediaPayload(params: {
+  args: Record<string, unknown>;
+  encoded: string;
+  maxBytes?: number;
+}):
+  | {
+      buffer: Buffer;
+      contentType?: string;
+      fileName?: string;
+    }
+  | undefined {
+  if (params.maxBytes !== undefined) {
+    const estimatedBytes = estimateBase64DecodedBytes(params.encoded);
+    if (estimatedBytes > params.maxBytes) {
+      throw new Error(
+        `WhatsApp upload-file buffer exceeds configured media limit (${estimatedBytes} bytes > ${params.maxBytes} bytes).`,
+      );
+    }
+  }
+  const contentType =
+    readStringParam(params.args, "contentType") ?? readStringParam(params.args, "mimeType");
+  const fileName =
+    readStringParam(params.args, "filename") ?? readStringParam(params.args, "fileName");
+  const buffer = Buffer.from(extractBase64Payload(params.encoded), "base64");
+  if (params.maxBytes !== undefined && buffer.byteLength > params.maxBytes) {
+    throw new Error(
+      `WhatsApp upload-file buffer exceeds configured media limit (${buffer.byteLength} bytes > ${params.maxBytes} bytes).`,
+    );
+  }
+  return {
+    buffer,
+    ...(contentType ? { contentType } : {}),
+    ...(fileName ? { fileName } : {}),
+  };
+}
+
+async function handleWhatsAppUploadFileAction(params: WhatsAppMessageActionParams) {
+  const mediaUrl = readUploadFileMediaSource(params.params);
+  const encodedPayload = readStringParam(params.params, "buffer", { trim: false });
+  if (!mediaUrl && !hasUploadFileBufferPayload(params.params)) {
+    throw new Error(
+      "WhatsApp upload-file requires media, mediaUrl, filePath, path, fileUrl, or buffer.",
+    );
+  }
+  const to = readStringParam(params.params, "to", { required: true });
+  const resolved = resolveAuthorizedWhatsAppOutboundTarget({
+    cfg: params.cfg,
+    chatJid: to,
+    accountId: params.accountId ?? undefined,
+    actionLabel: "upload-file",
+  });
+  const account = resolveWhatsAppAccount({
+    cfg: params.cfg,
+    accountId: resolved.accountId,
+  });
+  const mediaPayload = encodedPayload
+    ? decodeUploadFileMediaPayload({
+        args: params.params,
+        encoded: encodedPayload,
+        maxBytes: resolveWhatsAppMediaMaxBytes(account),
+      })
+    : undefined;
+  const result = await sendMessageWhatsApp(resolved.to, readUploadFileCaptionText(params.params), {
+    verbose: false,
+    cfg: params.cfg,
+    ...(mediaUrl && !mediaPayload ? { mediaUrl } : {}),
+    ...(mediaPayload ? { mediaPayload } : {}),
+    mediaAccess: params.mediaAccess,
+    mediaLocalRoots: params.mediaLocalRoots,
+    mediaReadFile: params.mediaReadFile,
+    gifPlayback: readBooleanParam(params.params, "gifPlayback") ?? undefined,
+    audioAsVoice:
+      readBooleanParam(params.params, "asVoice") ??
+      readBooleanParam(params.params, "audioAsVoice") ??
+      undefined,
+    forceDocument:
+      readBooleanParam(params.params, "forceDocument") ??
+      readBooleanParam(params.params, "asDocument") ??
+      undefined,
+    accountId: resolved.accountId,
+  });
+  return jsonResult({
+    ok: true,
+    channel: WHATSAPP_CHANNEL,
+    action: "upload-file",
+    messageId: result.messageId,
+    toJid: result.toJid,
+  });
+}
+
+export async function handleWhatsAppMessageAction(params: WhatsAppMessageActionParams) {
+  if (params.action === "upload-file") {
+    return await handleWhatsAppUploadFileAction(params);
+  }
+  if (params.action !== "react") {
+    throw new Error(`Action ${params.action} is not supported for provider ${WHATSAPP_CHANNEL}.`);
+  }
+  const isWhatsAppSource = params.toolContext?.currentChannelProvider === WHATSAPP_CHANNEL;
+  const explicitTarget =
+    readStringParam(params.params, "chatJid") ?? readStringParam(params.params, "to");
+  const normalizedTarget = explicitTarget ? normalizeWhatsAppTarget(explicitTarget) : null;
+  const normalizedCurrent =
+    isWhatsAppSource && params.toolContext?.currentChannelId
+      ? normalizeWhatsAppTarget(params.toolContext.currentChannelId)
+      : null;
+  const isCrossChat =
+    normalizedTarget != null &&
+    (normalizedCurrent == null || normalizedTarget !== normalizedCurrent);
+  const scopedContext =
+    !isWhatsAppSource || isCrossChat || !params.toolContext
+      ? undefined
+      : {
+          currentChannelId: params.toolContext.currentChannelId ?? undefined,
+          currentChannelProvider: params.toolContext.currentChannelProvider ?? undefined,
+          currentMessageId: params.toolContext.currentMessageId ?? undefined,
+        };
+  const messageIdRaw = resolveReactionMessageId({
+    args: params.params,
+    toolContext: scopedContext,
+  });
+  if (messageIdRaw == null) {
+    readStringParam(params.params, "messageId", { required: true });
+  }
+  const messageId = String(messageIdRaw);
+  const explicitMessageId = readStringOrNumberParam(params.params, "messageId");
+  const emoji = readStringParam(params.params, "emoji", { allowEmpty: true });
+  const remove = typeof params.params.remove === "boolean" ? params.params.remove : undefined;
+  const explicitParticipant = readStringParam(params.params, "participant");
+  const inferredParticipant =
+    explicitParticipant ||
+    explicitMessageId != null ||
+    !isWhatsAppSource ||
+    isCrossChat ||
+    !isWhatsAppGroupJid(explicitTarget ?? params.toolContext?.currentChannelId ?? "")
+      ? undefined
+      : typeof params.requesterSenderId === "string" && params.requesterSenderId.trim().length > 0
+        ? params.requesterSenderId.trim()
+        : undefined;
+  return await handleWhatsAppAction(
+    {
+      action: "react",
+      chatJid:
+        readStringParam(params.params, "chatJid") ??
+        readStringParam(params.params, "to", { required: true }),
+      messageId,
+      emoji,
+      remove,
+      participant: explicitParticipant ?? inferredParticipant,
+      accountId: params.accountId ?? undefined,
+      fromMe: typeof params.params.fromMe === "boolean" ? params.params.fromMe : undefined,
+    },
+    params.cfg,
+  );
+}
+
+export const handleWhatsAppReactAction = handleWhatsAppMessageAction;

package/src/channel.runtime.ts

@@ -0,0 +1,117 @@
+import {
+  startWebLoginWithQr as startWebLoginWithQrImpl,
+  waitForWebLogin as waitForWebLoginImpl,
+} from "../login-qr-runtime.js";
+import { getActiveWebListener as getActiveWebListenerImpl } from "./active-listener.js";
+import {
+  getWebAuthAgeMs as getWebAuthAgeMsImpl,
+  logWebSelfId as logWebSelfIdImpl,
+  logoutWeb as logoutWebImpl,
+  readWebAuthSnapshot as readWebAuthSnapshotImpl,
+  readWebAuthState as readWebAuthStateImpl,
+  readWebAuthExistsBestEffort as readWebAuthExistsBestEffortImpl,
+  readWebAuthExistsForDecision as readWebAuthExistsForDecisionImpl,
+  readWebAuthSnapshotBestEffort as readWebAuthSnapshotBestEffortImpl,
+  readWebSelfId as readWebSelfIdImpl,
+  webAuthExists as webAuthExistsImpl,
+} from "./auth-store.js";
+import { monitorWebChannel as monitorWebChannelImpl } from "./auto-reply/monitor.js";
+import { loginWeb as loginWebImpl } from "./login.js";
+import { whatsappSetupWizard as whatsappSetupWizardImpl } from "./setup-surface.js";
+
+type GetActiveWebListener = typeof import("./active-listener.js").getActiveWebListener;
+type GetWebAuthAgeMs = typeof import("./auth-store.js").getWebAuthAgeMs;
+type LogWebSelfId = typeof import("./auth-store.js").logWebSelfId;
+type LogoutWeb = typeof import("./auth-store.js").logoutWeb;
+type ReadWebAuthSnapshot = typeof import("./auth-store.js").readWebAuthSnapshot;
+type ReadWebAuthState = typeof import("./auth-store.js").readWebAuthState;
+type ReadWebAuthExistsBestEffort = typeof import("./auth-store.js").readWebAuthExistsBestEffort;
+type ReadWebAuthExistsForDecision = typeof import("./auth-store.js").readWebAuthExistsForDecision;
+type ReadWebAuthSnapshotBestEffort = typeof import("./auth-store.js").readWebAuthSnapshotBestEffort;
+type ReadWebSelfId = typeof import("./auth-store.js").readWebSelfId;
+type WebAuthExists = typeof import("./auth-store.js").webAuthExists;
+type LoginWeb = typeof import("./login.js").loginWeb;
+type StartWebLoginWithQr = typeof import("../login-qr-runtime.js").startWebLoginWithQr;
+type WaitForWebLogin = typeof import("../login-qr-runtime.js").waitForWebLogin;
+type WhatsAppSetupWizard = typeof import("./setup-surface.js").whatsappSetupWizard;
+type MonitorWebChannel = typeof import("./auto-reply/monitor.js").monitorWebChannel;
+
+export function getActiveWebListener(
+  ...args: Parameters<GetActiveWebListener>
+): ReturnType<GetActiveWebListener> {
+  return getActiveWebListenerImpl(...args);
+}
+
+export function getWebAuthAgeMs(...args: Parameters<GetWebAuthAgeMs>): ReturnType<GetWebAuthAgeMs> {
+  return getWebAuthAgeMsImpl(...args);
+}
+
+export function logWebSelfId(...args: Parameters<LogWebSelfId>): ReturnType<LogWebSelfId> {
+  return logWebSelfIdImpl(...args);
+}
+
+export function logoutWeb(...args: Parameters<LogoutWeb>): ReturnType<LogoutWeb> {
+  return logoutWebImpl(...args);
+}
+
+export function readWebAuthSnapshot(
+  ...args: Parameters<ReadWebAuthSnapshot>
+): ReturnType<ReadWebAuthSnapshot> {
+  return readWebAuthSnapshotImpl(...args);
+}
+
+export function readWebAuthState(
+  ...args: Parameters<ReadWebAuthState>
+): ReturnType<ReadWebAuthState> {
+  return readWebAuthStateImpl(...args);
+}
+
+export function readWebAuthExistsBestEffort(
+  ...args: Parameters<ReadWebAuthExistsBestEffort>
+): ReturnType<ReadWebAuthExistsBestEffort> {
+  return readWebAuthExistsBestEffortImpl(...args);
+}
+
+export function readWebAuthExistsForDecision(
+  ...args: Parameters<ReadWebAuthExistsForDecision>
+): ReturnType<ReadWebAuthExistsForDecision> {
+  return readWebAuthExistsForDecisionImpl(...args);
+}
+
+export function readWebAuthSnapshotBestEffort(
+  ...args: Parameters<ReadWebAuthSnapshotBestEffort>
+): ReturnType<ReadWebAuthSnapshotBestEffort> {
+  return readWebAuthSnapshotBestEffortImpl(...args);
+}
+
+export function readWebSelfId(...args: Parameters<ReadWebSelfId>): ReturnType<ReadWebSelfId> {
+  return readWebSelfIdImpl(...args);
+}
+
+export function webAuthExists(...args: Parameters<WebAuthExists>): ReturnType<WebAuthExists> {
+  return webAuthExistsImpl(...args);
+}
+
+export function loginWeb(...args: Parameters<LoginWeb>): ReturnType<LoginWeb> {
+  return loginWebImpl(...args);
+}
+
+export async function startWebLoginWithQr(
+  ...args: Parameters<StartWebLoginWithQr>
+): ReturnType<StartWebLoginWithQr> {
+  return await startWebLoginWithQrImpl(...args);
+}
+
+export async function waitForWebLogin(
+  ...args: Parameters<WaitForWebLogin>
+): ReturnType<WaitForWebLogin> {
+  return await waitForWebLoginImpl(...args);
+}
+
+export const whatsappSetupWizard: WhatsAppSetupWizard = { ...whatsappSetupWizardImpl };
+
+export function monitorWebChannel(
+  ...args: Parameters<MonitorWebChannel>
+): ReturnType<MonitorWebChannel> {
+  return monitorWebChannelImpl(...args);
+}