@openclaw/whatsapp 2026.5.2 → 2026.5.3-beta.2

package/src/outbound-base.ts

@@ -1,244 +0,0 @@
-import {
-  DEFAULT_ACCOUNT_ID,
-  listCombinedAccountIds,
-  normalizeOptionalAccountId,
-  resolveListedDefaultAccountId,
-} from "openclaw/plugin-sdk/account-core";
-import {
-  createAttachedChannelResultAdapter,
-  type ChannelOutboundAdapter,
-} from "openclaw/plugin-sdk/channel-send-result";
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { resolveOutboundSendDep } from "openclaw/plugin-sdk/outbound-send-deps";
-import { sendTextMediaPayload } from "openclaw/plugin-sdk/reply-payload";
-import {
-  normalizeWhatsAppOutboundPayload,
-  normalizeWhatsAppPayloadText,
-} from "./outbound-media-contract.js";
-import { WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS } from "./outbound-send-deps.js";
-import { lookupInboundMessageMetaForTarget } from "./quoted-message.js";
-import { toWhatsappJid } from "./text-runtime.js";
-
-type WhatsAppChunker = NonNullable<ChannelOutboundAdapter["chunker"]>;
-type WhatsAppSendTextOptions = {
-  verbose: boolean;
-  cfg: OpenClawConfig;
-  mediaUrl?: string;
-  mediaAccess?: {
-    localRoots?: readonly string[];
-    readFile?: (filePath: string) => Promise<Buffer>;
-  };
-  mediaLocalRoots?: readonly string[];
-  mediaReadFile?: (filePath: string) => Promise<Buffer>;
-  gifPlayback?: boolean;
-  audioAsVoice?: boolean;
-  accountId?: string;
-  quotedMessageKey?: {
-    id: string;
-    remoteJid: string;
-    fromMe: boolean;
-    participant?: string;
-    messageText?: string;
-  };
-  preserveLeadingWhitespace?: boolean;
-};
-type WhatsAppSendMessage = (
-  to: string,
-  body: string,
-  options: WhatsAppSendTextOptions,
-) => Promise<{ messageId: string; toJid: string }>;
-type WhatsAppSendPoll = (
-  to: string,
-  poll: Parameters<NonNullable<ChannelOutboundAdapter["sendPoll"]>>[0]["poll"],
-  options: { verbose: boolean; accountId?: string; cfg: OpenClawConfig },
-) => Promise<{ messageId: string; toJid: string }>;
-
-type CreateWhatsAppOutboundBaseParams = {
-  chunker: WhatsAppChunker;
-  sendMessageWhatsApp: WhatsAppSendMessage;
-  sendPollWhatsApp: WhatsAppSendPoll;
-  shouldLogVerbose: () => boolean;
-  resolveTarget: ChannelOutboundAdapter["resolveTarget"];
-  normalizeText?: (text: string | undefined) => string;
-  skipEmptyText?: boolean;
-};
-
-function resolveQuoteLookupAccountId(cfg?: OpenClawConfig, accountId?: string | null): string {
-  const explicitAccountId = normalizeOptionalAccountId(accountId);
-  if (explicitAccountId) {
-    return explicitAccountId;
-  }
-  const channelCfg = cfg?.channels?.whatsapp;
-  const configuredIds = listCombinedAccountIds({
-    configuredAccountIds:
-      channelCfg?.accounts && typeof channelCfg.accounts === "object"
-        ? Object.keys(channelCfg.accounts).filter(Boolean)
-        : [],
-    fallbackAccountIdWhenEmpty: DEFAULT_ACCOUNT_ID,
-  });
-  return resolveListedDefaultAccountId({
-    accountIds: configuredIds,
-    configuredDefaultAccountId: normalizeOptionalAccountId(channelCfg?.defaultAccount),
-  });
-}
-
-type WhatsAppOutboundBaseCore = Pick<
-  ChannelOutboundAdapter,
-  | "deliveryMode"
-  | "chunker"
-  | "chunkerMode"
-  | "textChunkLimit"
-  | "sanitizeText"
-  | "pollMaxOptions"
-  | "resolveTarget"
-  | "sendText"
-  | "sendMedia"
-  | "sendPoll"
->;
-
-export function createWhatsAppOutboundBase({
-  chunker,
-  sendMessageWhatsApp,
-  sendPollWhatsApp,
-  shouldLogVerbose,
-  resolveTarget,
-  normalizeText = normalizeWhatsAppPayloadText,
-  skipEmptyText = true,
-}: CreateWhatsAppOutboundBaseParams): Pick<
-  ChannelOutboundAdapter,
-  | "deliveryMode"
-  | "chunker"
-  | "chunkerMode"
-  | "textChunkLimit"
-  | "sanitizeText"
-  | "pollMaxOptions"
-  | "resolveTarget"
-  | "sendPayload"
-  | "sendText"
-  | "sendMedia"
-  | "sendPoll"
-> {
-  const resolveQuotedMessageKey = (params: {
-    accountId: string;
-    to: string;
-    replyToId?: string | null;
-  }) => {
-    const replyToId = params.replyToId?.trim();
-    if (!replyToId) {
-      return undefined;
-    }
-    const targetJid = toWhatsappJid(params.to);
-    const cachedMeta = lookupInboundMessageMetaForTarget(params.accountId, targetJid, replyToId);
-    return {
-      id: replyToId,
-      remoteJid: cachedMeta?.remoteJid ?? targetJid,
-      fromMe: cachedMeta?.fromMe ?? false,
-      participant: cachedMeta?.participant,
-      messageText: cachedMeta?.body,
-    };
-  };
-
-  const outbound: WhatsAppOutboundBaseCore = {
-    deliveryMode: "gateway",
-    chunker,
-    chunkerMode: "text",
-    textChunkLimit: 4000,
-    sanitizeText: ({ text }) => normalizeText(text),
-    pollMaxOptions: 12,
-    resolveTarget,
-    ...createAttachedChannelResultAdapter({
-      channel: "whatsapp",
-      sendText: async ({ cfg, to, text, accountId, deps, gifPlayback, replyToId }) => {
-        const normalizedText = normalizeText(text);
-        if (skipEmptyText && !normalizedText) {
-          return { messageId: "" };
-        }
-        const send =
-          resolveOutboundSendDep<WhatsAppSendMessage>(deps, "whatsapp", {
-            legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS,
-          }) ?? sendMessageWhatsApp;
-        const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
-        const quotedMessageKey = resolveQuotedMessageKey({
-          accountId: lookupAccountId,
-          to,
-          replyToId,
-        });
-        return await send(to, normalizedText, {
-          verbose: false,
-          cfg,
-          accountId: accountId ?? undefined,
-          gifPlayback,
-          quotedMessageKey,
-        });
-      },
-      sendMedia: async ({
-        cfg,
-        to,
-        text,
-        mediaUrl,
-        mediaAccess,
-        mediaLocalRoots,
-        mediaReadFile,
-        audioAsVoice,
-        accountId,
-        deps,
-        gifPlayback,
-        replyToId,
-      }) => {
-        const send =
-          resolveOutboundSendDep<WhatsAppSendMessage>(deps, "whatsapp", {
-            legacyKeys: WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS,
-          }) ?? sendMessageWhatsApp;
-        const lookupAccountId = resolveQuoteLookupAccountId(cfg, accountId);
-        const quotedMessageKey = resolveQuotedMessageKey({
-          accountId: lookupAccountId,
-          to,
-          replyToId,
-        });
-        return await send(to, normalizeText(text), {
-          verbose: false,
-          cfg,
-          mediaUrl,
-          mediaAccess,
-          mediaLocalRoots,
-          mediaReadFile,
-          ...(audioAsVoice === undefined ? {} : { audioAsVoice }),
-          accountId: accountId ?? undefined,
-          gifPlayback,
-          quotedMessageKey,
-        });
-      },
-      sendPoll: async ({ cfg, to, poll, accountId }) =>
-        await sendPollWhatsApp(to, poll, {
-          verbose: shouldLogVerbose(),
-          accountId: accountId ?? undefined,
-          cfg,
-        }),
-    }),
-  };
-  return {
-    ...outbound,
-    sendPayload: async (ctx) => {
-      if (ctx.payload.isError === true) {
-        return { channel: "whatsapp", messageId: "" };
-      }
-      const payload = normalizeWhatsAppOutboundPayload(ctx.payload, { normalizeText });
-      if (!payload.text && !(payload.mediaUrl || payload.mediaUrls?.length)) {
-        if (ctx.payload.interactive || ctx.payload.presentation || ctx.payload.channelData) {
-          throw new Error(
-            "WhatsApp sendPayload does not support structured-only payloads without text or media.",
-          );
-        }
-        return { channel: "whatsapp", messageId: "" };
-      }
-      return await sendTextMediaPayload({
-        channel: "whatsapp",
-        ctx: {
-          ...ctx,
-          payload,
-        },
-        adapter: outbound,
-      });
-    },
-  };
-}

package/src/outbound-media-contract.ts

@@ -1,278 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS, runFfmpeg } from "openclaw/plugin-sdk/media-runtime";
-import { sanitizeForPlainText } from "openclaw/plugin-sdk/outbound-runtime";
-import { resolvePreferredOpenClawTmpDir } from "openclaw/plugin-sdk/temp-path";
-import { formatError } from "./session-errors.js";
-import {
-  sanitizeAssistantVisibleText,
-  sanitizeAssistantVisibleTextWithProfile,
-  stripToolCallXmlTags,
-  sleep,
-} from "./text-runtime.js";
-
-type WhatsAppOutboundPayloadLike = {
-  text?: string;
-  mediaUrl?: string;
-  mediaUrls?: readonly string[];
-};
-
-type WhatsAppLoadedMediaLike = {
-  buffer: Buffer;
-  contentType?: string;
-  kind?: string;
-  fileName?: string;
-};
-
-type NormalizedWhatsAppOutboundPayload<T extends WhatsAppOutboundPayloadLike> = Omit<
-  T,
-  "text" | "mediaUrl" | "mediaUrls"
-> & {
-  text: string;
-  mediaUrl?: string;
-  mediaUrls?: string[];
-};
-
-export type DeliverableWhatsAppOutboundPayload<T extends WhatsAppOutboundPayloadLike> = Omit<
-  NormalizedWhatsAppOutboundPayload<T>,
-  "text"
-> & {
-  text?: string;
-};
-
-type CanonicalWhatsAppLoadedMedia = {
-  buffer: Buffer;
-  kind: "image" | "audio" | "video" | "document";
-  mimetype: string;
-  fileName?: string;
-};
-
-const WHATSAPP_VOICE_FILE_NAME = "voice.ogg";
-const WHATSAPP_VOICE_SAMPLE_RATE_HZ = 48_000;
-const WHATSAPP_VOICE_BITRATE = "64k";
-const WHATSAPP_VOICE_MIMETYPE = "audio/ogg; codecs=opus";
-
-function stripWhatsAppPluralToolXml(text: string): string {
-  return stripToolCallXmlTags(text, { stripFunctionCallsXmlPayloads: true });
-}
-
-function finalizeWhatsAppVisibleText(text: string): string {
-  return sanitizeForPlainText(stripWhatsAppPluralToolXml(text));
-}
-
-export function normalizeWhatsAppPayloadText(text: string | undefined): string {
-  return finalizeWhatsAppVisibleText(sanitizeAssistantVisibleText(text ?? "")).trimStart();
-}
-
-function stripLeadingBlankLines(text: string): string {
-  return text.replace(/^(?:[ \t]*\r?\n)+/, "");
-}
-
-export function normalizeWhatsAppPayloadTextPreservingIndentation(
-  text: string | undefined,
-): string {
-  const sanitized = sanitizeAssistantVisibleTextWithProfile(
-    stripLeadingBlankLines(text ?? ""),
-    "history",
-  );
-  const normalized = stripLeadingBlankLines(finalizeWhatsAppVisibleText(sanitized));
-  return normalized.trim() ? normalized : "";
-}
-
-export function resolveWhatsAppOutboundMediaUrls(
-  payload: Pick<WhatsAppOutboundPayloadLike, "mediaUrl" | "mediaUrls">,
-): string[] {
-  const primaryMediaUrl = payload.mediaUrl?.trim();
-  const mediaUrls = (payload.mediaUrls ? [...payload.mediaUrls] : [])
-    .map((entry) => entry.trim())
-    .filter((entry): entry is string => Boolean(entry));
-  const orderedMediaUrls = [primaryMediaUrl, ...mediaUrls].filter((entry): entry is string =>
-    Boolean(entry),
-  );
-  return Array.from(new Set(orderedMediaUrls));
-}
-
-// Keep new WhatsApp outbound-media behavior in this helper so payload, gateway, and auto-reply paths stay aligned.
-export function normalizeWhatsAppOutboundPayload<T extends WhatsAppOutboundPayloadLike>(
-  payload: T,
-  options?: {
-    normalizeText?: (text: string | undefined) => string;
-  },
-): NormalizedWhatsAppOutboundPayload<T> {
-  const mediaUrls = resolveWhatsAppOutboundMediaUrls(payload);
-  const normalizeText = options?.normalizeText ?? normalizeWhatsAppPayloadText;
-  return {
-    ...payload,
-    text: normalizeText(payload.text),
-    mediaUrl: mediaUrls[0],
-    mediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
-  };
-}
-
-function normalizeWhatsAppLoadedMedia(
-  media: WhatsAppLoadedMediaLike,
-  mediaUrl?: string,
-): CanonicalWhatsAppLoadedMedia {
-  const kind =
-    media.kind === "image" || media.kind === "audio" || media.kind === "video"
-      ? media.kind
-      : "document";
-  const mimetype =
-    kind === "audio" && isWhatsAppNativeVoiceAudio({ contentType: media.contentType, mediaUrl })
-      ? WHATSAPP_VOICE_MIMETYPE
-      : (media.contentType ?? "application/octet-stream");
-  const fileName =
-    kind === "document"
-      ? (media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl) ?? "file")
-      : undefined;
-  return {
-    buffer: media.buffer,
-    kind,
-    mimetype,
-    ...(fileName ? { fileName } : {}),
-  };
-}
-
-export async function prepareWhatsAppOutboundMedia(
-  media: WhatsAppLoadedMediaLike,
-  mediaUrl?: string,
-): Promise<CanonicalWhatsAppLoadedMedia> {
-  const normalized = normalizeWhatsAppLoadedMedia(media, mediaUrl);
-  if (normalized.kind !== "audio") {
-    return normalized;
-  }
-  if (
-    isWhatsAppNativeVoiceAudio({
-      contentType: media.contentType,
-      fileName: media.fileName,
-      mediaUrl,
-    })
-  ) {
-    return normalized;
-  }
-
-  const buffer = await transcodeToWhatsAppVoiceOpus({
-    buffer: media.buffer,
-    fileName: media.fileName ?? deriveWhatsAppDocumentFileName(mediaUrl) ?? "audio",
-  });
-  return {
-    buffer,
-    kind: "audio",
-    mimetype: WHATSAPP_VOICE_MIMETYPE,
-  };
-}
-
-function normalizeContentType(value: string | undefined): string {
-  return value?.split(";", 1)[0]?.trim().toLowerCase() ?? "";
-}
-
-function isWhatsAppNativeVoiceAudio(params: {
-  contentType?: string;
-  fileName?: string;
-  mediaUrl?: string;
-}): boolean {
-  const contentType = normalizeContentType(params.contentType);
-  if (contentType === "audio/ogg" || contentType === "audio/opus") {
-    return true;
-  }
-  const fileName = params.fileName ?? deriveWhatsAppDocumentFileName(params.mediaUrl) ?? "";
-  const ext = path.extname(fileName).toLowerCase();
-  return ext === ".ogg" || ext === ".opus";
-}
-
-async function transcodeToWhatsAppVoiceOpus(params: {
-  buffer: Buffer;
-  fileName: string;
-}): Promise<Buffer> {
-  const tempRoot = resolvePreferredOpenClawTmpDir();
-  await fs.mkdir(tempRoot, { recursive: true, mode: 0o700 });
-  const tempDir = await fs.mkdtemp(path.join(tempRoot, "whatsapp-voice-"));
-  try {
-    const ext = path.extname(params.fileName).toLowerCase();
-    const inputExt = ext && ext.length <= 12 ? ext : ".audio";
-    const inputPath = path.join(tempDir, `input${inputExt}`);
-    const outputPath = path.join(tempDir, WHATSAPP_VOICE_FILE_NAME);
-    await fs.writeFile(inputPath, params.buffer, { mode: 0o600 });
-    await runFfmpeg([
-      "-hide_banner",
-      "-loglevel",
-      "error",
-      "-y",
-      "-i",
-      inputPath,
-      "-vn",
-      "-sn",
-      "-dn",
-      "-t",
-      String(MEDIA_FFMPEG_MAX_AUDIO_DURATION_SECS),
-      "-ar",
-      String(WHATSAPP_VOICE_SAMPLE_RATE_HZ),
-      "-ac",
-      "1",
-      "-c:a",
-      "libopus",
-      "-b:a",
-      WHATSAPP_VOICE_BITRATE,
-      outputPath,
-    ]);
-    return await fs.readFile(outputPath);
-  } finally {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  }
-}
-
-function deriveWhatsAppDocumentFileName(mediaUrl: string | undefined): string | undefined {
-  if (!mediaUrl) {
-    return undefined;
-  }
-  try {
-    const parsed = new URL(mediaUrl);
-    const fileName = path.posix.basename(parsed.pathname);
-    return fileName ? decodeURIComponent(fileName) : undefined;
-  } catch {
-    const withoutQueryOrFragment = mediaUrl.split(/[?#]/, 1)[0] ?? "";
-    const fileName = withoutQueryOrFragment.split(/[\\/]/).pop();
-    return fileName || undefined;
-  }
-}
-
-function isRetryableWhatsAppOutboundError(error: unknown): boolean {
-  return /closed|reset|timed\s*out|disconnect/i.test(formatError(error));
-}
-
-export async function sendWhatsAppOutboundWithRetry<T>(params: {
-  send: () => Promise<T>;
-  onRetry?: (params: {
-    attempt: number;
-    maxAttempts: number;
-    backoffMs: number;
-    error: unknown;
-    errorText: string;
-  }) => Promise<void> | void;
-  maxAttempts?: number;
-}): Promise<T> {
-  const maxAttempts = params.maxAttempts ?? 3;
-  let lastError: unknown;
-  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-    try {
-      return await params.send();
-    } catch (error) {
-      lastError = error;
-      const errorText = formatError(error);
-      const isLastAttempt = attempt === maxAttempts;
-      if (!isRetryableWhatsAppOutboundError(error) || isLastAttempt) {
-        throw error;
-      }
-      const backoffMs = 500 * attempt;
-      await params.onRetry?.({
-        attempt,
-        maxAttempts,
-        backoffMs,
-        error,
-        errorText,
-      });
-      await sleep(backoffMs);
-    }
-  }
-  throw lastError;
-}

package/src/outbound-media.runtime.ts

@@ -1,36 +0,0 @@
-import { loadWebMedia } from "openclaw/plugin-sdk/web-media";
-
-export async function loadOutboundMediaFromUrl(
-  mediaUrl: string,
-  options: {
-    maxBytes?: number;
-    mediaAccess?: {
-      localRoots?: readonly string[];
-      readFile?: (filePath: string) => Promise<Buffer>;
-    };
-    mediaLocalRoots?: readonly string[];
-    mediaReadFile?: (filePath: string) => Promise<Buffer>;
-  } = {},
-) {
-  const readFile = options.mediaAccess?.readFile ?? options.mediaReadFile;
-  const localRoots =
-    options.mediaAccess?.localRoots?.length && options.mediaAccess.localRoots.length > 0
-      ? options.mediaAccess.localRoots
-      : options.mediaLocalRoots && options.mediaLocalRoots.length > 0
-        ? options.mediaLocalRoots
-        : undefined;
-  return await loadWebMedia(
-    mediaUrl,
-    readFile
-      ? {
-          ...(options.maxBytes !== undefined ? { maxBytes: options.maxBytes } : {}),
-          localRoots: "any",
-          readFile,
-          hostReadCapability: true,
-        }
-      : {
-          ...(options.maxBytes !== undefined ? { maxBytes: options.maxBytes } : {}),
-          ...(localRoots ? { localRoots } : {}),
-        },
-  );
-}

package/src/outbound-payload.contract.test.ts

@@ -1,61 +0,0 @@
-import {
-  installChannelOutboundPayloadContractSuite,
-  primeChannelOutboundSendMock,
-  type OutboundPayloadHarnessParams,
-} from "openclaw/plugin-sdk/channel-contract-testing";
-import { describe, expect, it, vi } from "vitest";
-import { whatsappOutbound } from "./outbound-adapter.js";
-
-function createWhatsAppHarness(params: OutboundPayloadHarnessParams) {
-  const sendWhatsApp = vi.fn();
-  primeChannelOutboundSendMock(sendWhatsApp, { messageId: "wa-1" }, params.sendResults);
-  const ctx = {
-    cfg: {},
-    to: "5511999999999@c.us",
-    text: "",
-    payload: params.payload,
-    deps: {
-      whatsapp: sendWhatsApp,
-    },
-  };
-  return {
-    run: async () => await whatsappOutbound.sendPayload!(ctx),
-    sendMock: sendWhatsApp,
-    to: ctx.to,
-  };
-}
-
-describe("WhatsApp outbound payload contract", () => {
-  installChannelOutboundPayloadContractSuite({
-    channel: "whatsapp",
-    chunking: { mode: "split", longTextLength: 5000, maxChunkLength: 4000 },
-    createHarness: createWhatsAppHarness,
-  });
-
-  it("normalizes blank mediaUrls before contract delivery", async () => {
-    const sendWhatsApp = vi.fn();
-    primeChannelOutboundSendMock(sendWhatsApp, { messageId: "wa-1" });
-
-    await whatsappOutbound.sendPayload!({
-      cfg: {},
-      to: "5511999999999@c.us",
-      text: "",
-      payload: {
-        text: "\n\ncaption",
-        mediaUrls: ["   ", " /tmp/voice.ogg "],
-      },
-      deps: {
-        whatsapp: sendWhatsApp,
-      },
-    });
-
-    expect(sendWhatsApp).toHaveBeenCalledTimes(1);
-    expect(sendWhatsApp).toHaveBeenCalledWith(
-      "5511999999999@c.us",
-      "caption",
-      expect.objectContaining({
-        mediaUrl: "/tmp/voice.ogg",
-      }),
-    );
-  });
-});

package/src/outbound-send-deps.ts

@@ -1 +0,0 @@
-export const WHATSAPP_LEGACY_OUTBOUND_SEND_DEP_KEYS = ["sendWhatsApp"] as const;

package/src/outbound-test-support.ts

@@ -1,16 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-
-export function createWhatsAppPollFixture() {
-  const cfg = { marker: "resolved-cfg" } as OpenClawConfig;
-  const poll = {
-    question: "Lunch?",
-    options: ["Pizza", "Sushi"],
-    maxSelections: 1,
-  };
-  return {
-    cfg,
-    poll,
-    to: "+1555",
-    accountId: "work",
-  };
-}

package/src/pairing-security.test-harness.ts

@@ -1,59 +0,0 @@
-import { vi, type Mock } from "vitest";
-
-export type AsyncMock<TArgs extends unknown[] = unknown[], TResult = unknown> = {
-  (...args: TArgs): Promise<TResult>;
-  mockReset: () => AsyncMock<TArgs, TResult>;
-  mockResolvedValue: (value: TResult) => AsyncMock<TArgs, TResult>;
-  mockResolvedValueOnce: (value: TResult) => AsyncMock<TArgs, TResult>;
-};
-type UnknownMock = Mock<(...args: unknown[]) => unknown>;
-
-export const loadConfigMock: UnknownMock = vi.fn();
-export const readAllowFromStoreMock = vi.fn() as AsyncMock;
-export const upsertPairingRequestMock = vi.fn() as AsyncMock;
-
-export function resetPairingSecurityMocks(config: Record<string, unknown>) {
-  loadConfigMock.mockReset().mockReturnValue(config);
-  readAllowFromStoreMock.mockReset().mockResolvedValue([]);
-  upsertPairingRequestMock.mockReset().mockResolvedValue({ code: "PAIRCODE", created: true });
-}
-
-vi.mock("openclaw/plugin-sdk/runtime-config-snapshot", async () => {
-  const actual = await vi.importActual<
-    typeof import("openclaw/plugin-sdk/runtime-config-snapshot")
-  >("openclaw/plugin-sdk/runtime-config-snapshot");
-  return {
-    ...actual,
-    getRuntimeConfig: (...args: unknown[]) => loadConfigMock(...args),
-  };
-});
-
-vi.mock("openclaw/plugin-sdk/conversation-runtime", () => {
-  return {
-    upsertChannelPairingRequest: (...args: unknown[]) => upsertPairingRequestMock(...args),
-  };
-});
-
-vi.mock("openclaw/plugin-sdk/security-runtime", async () => {
-  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk/security-runtime")>(
-    "openclaw/plugin-sdk/security-runtime",
-  );
-  return {
-    ...actual,
-    readStoreAllowFromForDmPolicy: async (params: {
-      provider: string;
-      accountId: string;
-      dmPolicy?: string | null;
-      shouldRead?: boolean | null;
-    }) => {
-      if (params.shouldRead === false || params.dmPolicy === "allowlist") {
-        return [];
-      }
-      try {
-        return (await readAllowFromStoreMock(params.provider, params.accountId)) as string[];
-      } catch {
-        return [];
-      }
-    },
-  };
-});

package/src/qr-image.ts

@@ -1 +0,0 @@
-export { renderQrPngBase64, renderQrPngDataUrl } from "openclaw/plugin-sdk/media-runtime";

package/src/qr-terminal.ts

@@ -1 +0,0 @@
-export { renderQrTerminal } from "openclaw/plugin-sdk/media-runtime";