@openclaw/whatsapp 2026.5.2-beta.2 → 2026.5.3-beta.1

package/src/auto-reply/monitor/process-message.audio-preflight.test.ts

@@ -1,420 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock the lazy-loaded audio preflight runtime boundary
-const transcribeFirstAudioMock = vi.fn();
-const maybeSendAckReactionMock = vi.fn();
-
-vi.mock("./audio-preflight.runtime.js", () => ({
-  transcribeFirstAudio: (...args: unknown[]) => transcribeFirstAudioMock(...args),
-}));
-
-// Controllable shouldComputeCommandAuthorized for command-sync tests
-let shouldComputeCommandResult = false;
-let shouldComputeCommandBodies: string[] = [];
-
-// Minimal mocks for process-message dependencies
-vi.mock("../../accounts.js", () => ({
-  resolveWhatsAppAccount: () => ({
-    accountId: "default",
-    dmPolicy: "pairing",
-    groupPolicy: "allowlist",
-    allowFrom: [],
-  }),
-}));
-
-vi.mock("../../identity.js", () => ({
-  getPrimaryIdentityId: () => undefined,
-  getSelfIdentity: () => ({ e164: "+15550000001" }),
-  getSenderIdentity: () => ({ e164: "+15550000002", name: "Alice" }),
-}));
-
-vi.mock("../../reconnect.js", () => ({
-  newConnectionId: () => "test-conn-id",
-}));
-
-vi.mock("../../session.js", () => ({
-  formatError: (err: unknown) => String(err),
-}));
-
-vi.mock("../deliver-reply.js", () => ({
-  deliverWebReply: vi.fn(async () => {}),
-}));
-
-vi.mock("../loggers.js", () => ({
-  whatsappInboundLog: { info: () => {}, debug: () => {} },
-}));
-
-vi.mock("./ack-reaction.js", () => ({
-  maybeSendAckReaction: (...args: unknown[]) => maybeSendAckReactionMock(...args),
-}));
-
-vi.mock("./inbound-context.js", () => ({
-  resolveVisibleWhatsAppGroupHistory: () => [],
-  resolveVisibleWhatsAppReplyContext: () => null,
-}));
-
-vi.mock("./last-route.js", () => ({
-  trackBackgroundTask: () => {},
-  updateLastRouteInBackground: () => {},
-}));
-
-vi.mock("./message-line.js", () => ({
-  buildInboundLine: (params: { msg: { body: string } }) => params.msg.body,
-}));
-
-vi.mock("./runtime-api.js", () => ({
-  buildHistoryContextFromEntries: (_p: { currentMessage: string }) => _p.currentMessage,
-  createChannelReplyPipeline: () => ({ onModelSelected: undefined }),
-  formatInboundEnvelope: (p: { body: string }) => p.body,
-  logVerbose: () => {},
-  normalizeE164: (v: string) => v,
-  readStoreAllowFromForDmPolicy: async () => [],
-  recordSessionMetaFromInbound: async () => {},
-  resolveChannelContextVisibilityMode: () => "standard",
-  resolveInboundSessionEnvelopeContext: () => ({
-    storePath: "/tmp/sessions.json",
-    envelopeOptions: {},
-    previousTimestamp: undefined,
-  }),
-  resolvePinnedMainDmOwnerFromAllowlist: () => null,
-  resolveDmGroupAccessWithCommandGate: () => ({ commandAuthorized: true }),
-  shouldComputeCommandAuthorized: (body: string) => {
-    shouldComputeCommandBodies.push(body);
-    return shouldComputeCommandResult || body.startsWith("/");
-  },
-  shouldLogVerbose: () => false,
-  type: undefined,
-}));
-
-vi.mock("./inbound-dispatch.js", () => ({
-  buildWhatsAppInboundContext: (params: {
-    bodyForAgent?: string;
-    combinedBody: string;
-    commandAuthorized?: boolean;
-    commandBody?: string;
-    msg: { body: string; mediaPath?: string; mediaType?: string };
-    mediaTranscribedIndexes?: number[];
-    rawBody?: string;
-    transcript?: string;
-  }) => ({
-    Body: params.combinedBody,
-    BodyForAgent: params.bodyForAgent ?? params.msg.body,
-    CommandAuthorized: params.commandAuthorized,
-    CommandBody: params.commandBody ?? params.msg.body,
-    MediaPath: params.msg.mediaPath,
-    MediaType: params.msg.mediaType,
-    MediaTranscribedIndexes: params.mediaTranscribedIndexes,
-    RawBody: params.rawBody ?? params.msg.body,
-    Transcript: params.transcript,
-  }),
-  dispatchWhatsAppBufferedReply: vi.fn(async () => true),
-  resolveWhatsAppDmRouteTarget: () => "+15550000002",
-  resolveWhatsAppResponsePrefix: () => undefined,
-  updateWhatsAppMainLastRoute: () => {},
-}));
-
-import { dispatchWhatsAppBufferedReply } from "./inbound-dispatch.js";
-import { processMessage } from "./process-message.js";
-
-type WebInboundMsg = Parameters<typeof processMessage>[0]["msg"];
-type TestRoute = Parameters<typeof processMessage>[0]["route"];
-
-const flushMicrotasks = async () => {
-  await Promise.resolve();
-  await Promise.resolve();
-};
-
-function makeAudioMsg(overrides: Partial<WebInboundMsg> = {}): WebInboundMsg {
-  return {
-    id: "msg-1",
-    from: "+15550000002",
-    to: "+15550000001",
-    body: "<media:audio>",
-    chatType: "direct",
-    mediaType: "audio/ogg; codecs=opus",
-    mediaPath: "/tmp/voice.ogg",
-    timestamp: 1700000000,
-    accountId: "default",
-    ...overrides,
-  } as WebInboundMsg;
-}
-
-function makeRoute(overrides: Partial<TestRoute> = {}): TestRoute {
-  return {
-    agentId: "main",
-    sessionKey: "agent:main:main",
-    mainSessionKey: "agent:main:main",
-    accountId: "default",
-    ...overrides,
-  } as TestRoute;
-}
-
-function makeParams(msgOverrides: Partial<WebInboundMsg> = {}) {
-  return {
-    cfg: {
-      tools: { media: { audio: { enabled: true } } },
-      channels: { whatsapp: {} },
-      commands: { useAccessGroups: false },
-    } as never,
-    msg: makeAudioMsg(msgOverrides),
-    route: makeRoute(),
-    groupHistoryKey: "whatsapp:default:+15550000002",
-    groupHistories: new Map(),
-    groupMemberNames: new Map(),
-    connectionId: "conn-1",
-    verbose: false,
-    maxMediaBytes: 1024 * 1024,
-    replyResolver: vi.fn() as never,
-    replyLogger: {
-      info: () => {},
-      warn: () => {},
-      debug: () => {},
-      error: () => {},
-    } as never,
-    backgroundTasks: new Set<Promise<unknown>>(),
-    rememberSentText: () => {},
-    echoHas: () => false,
-    echoForget: () => {},
-    buildCombinedEchoKey: (p: { combinedBody: string }) => p.combinedBody,
-  };
-}
-
-function makeAckReactionHandle() {
-  return {
-    ackReactionPromise: Promise.resolve(true),
-    ackReactionValue: "👀",
-    remove: vi.fn(async () => undefined),
-  };
-}
-
-function makeRemoveAckAfterReplyParams() {
-  return {
-    ...makeParams(),
-    cfg: {
-      tools: { media: { audio: { enabled: true } } },
-      channels: { whatsapp: {} },
-      commands: { useAccessGroups: false },
-      messages: { removeAckAfterReply: true },
-    } as never,
-    preflightAudioTranscript: "pre-computed transcript from caller",
-  };
-}
-
-describe("processMessage audio preflight transcription", () => {
-  beforeEach(() => {
-    transcribeFirstAudioMock.mockReset();
-    maybeSendAckReactionMock.mockReset();
-    maybeSendAckReactionMock.mockResolvedValue(null);
-    shouldComputeCommandResult = false;
-    shouldComputeCommandBodies = [];
-    vi.mocked(dispatchWhatsAppBufferedReply).mockClear();
-  });
-
-  it("replaces <media:audio> body with transcript when transcription succeeds", async () => {
-    transcribeFirstAudioMock.mockResolvedValueOnce("okay let's test this voice message");
-
-    await processMessage(makeParams());
-
-    expect(transcribeFirstAudioMock).toHaveBeenCalledTimes(1);
-    expect(transcribeFirstAudioMock).toHaveBeenCalledWith(
-      expect.objectContaining({
-        ctx: expect.objectContaining({
-          MediaPaths: ["/tmp/voice.ogg"],
-          MediaTypes: ["audio/ogg; codecs=opus"],
-        }),
-      }),
-    );
-
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "okay let's test this voice message",
-      BodyForAgent: "okay let's test this voice message",
-      CommandBody: "<media:audio>",
-      RawBody: "<media:audio>",
-      Transcript: "okay let's test this voice message",
-      MediaTranscribedIndexes: [0],
-    });
-    // mediaPath and mediaType must be preserved so inboundAudio detection (used by
-    // features like messages.tts.auto: "inbound") still recognises this as audio.
-    expect(dispatchCall?.context).toMatchObject({
-      MediaPath: "/tmp/voice.ogg",
-      MediaType: "audio/ogg; codecs=opus",
-    });
-  });
-
-  it("falls back to <media:audio> placeholder when transcription fails", async () => {
-    transcribeFirstAudioMock.mockRejectedValueOnce(new Error("provider unavailable"));
-
-    await processMessage(makeParams());
-
-    expect(transcribeFirstAudioMock).toHaveBeenCalledTimes(1);
-
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "<media:audio>",
-      BodyForAgent: "<media:audio>",
-    });
-  });
-
-  it("falls back to <media:audio> placeholder when transcription returns undefined", async () => {
-    transcribeFirstAudioMock.mockResolvedValueOnce(undefined);
-
-    await processMessage(makeParams());
-
-    expect(transcribeFirstAudioMock).toHaveBeenCalledTimes(1);
-
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "<media:audio>",
-      BodyForAgent: "<media:audio>",
-    });
-  });
-
-  it("does not call transcribeFirstAudio when mediaType is not audio", async () => {
-    await processMessage(
-      makeParams({ body: "<media:image>", mediaType: "image/jpeg", mediaPath: "/tmp/img.jpg" }),
-    );
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-  });
-
-  it("does not call transcribeFirstAudio when body is not <media:audio>", async () => {
-    await processMessage(makeParams({ body: "hello there", mediaType: "audio/ogg; codecs=opus" }));
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-  });
-
-  it("does not call transcribeFirstAudio when mediaPath is absent", async () => {
-    await processMessage(makeParams({ mediaPath: undefined }));
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-  });
-
-  it("does not call transcribeFirstAudio when msg.mediaType is absent", async () => {
-    await processMessage(
-      makeParams({ mediaType: undefined, body: "<media:audio>", mediaPath: "/tmp/voice.ogg" }),
-    );
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-
-    // Body passes through as-is without a mediaType to confirm audio
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "<media:audio>",
-    });
-  });
-
-  it("does not use transcript body for command detection", async () => {
-    transcribeFirstAudioMock.mockResolvedValueOnce("/new start a new session");
-
-    await processMessage(makeParams());
-
-    expect(shouldComputeCommandBodies).toEqual(["<media:audio>"]);
-
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "/new start a new session",
-      BodyForAgent: "/new start a new session",
-      CommandBody: "<media:audio>",
-      RawBody: "<media:audio>",
-      Transcript: "/new start a new session",
-      MediaTranscribedIndexes: [0],
-    });
-  });
-
-  it("uses preflightAudioTranscript when provided, skipping transcribeFirstAudio", async () => {
-    // Simulate broadcast fan-out: caller pre-computed the transcript and passes it in.
-    // transcribeFirstAudio must NOT be called again inside processMessage.
-    await processMessage({
-      ...makeParams(),
-      preflightAudioTranscript: "pre-computed transcript from fan-out caller",
-    });
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "pre-computed transcript from fan-out caller",
-      BodyForAgent: "pre-computed transcript from fan-out caller",
-      CommandBody: "<media:audio>",
-      RawBody: "<media:audio>",
-      Transcript: "pre-computed transcript from fan-out caller",
-      MediaTranscribedIndexes: [0],
-    });
-  });
-
-  it("does not send a duplicate ack when caller already sent it", async () => {
-    await processMessage({
-      ...makeParams(),
-      preflightAudioTranscript: "pre-computed transcript from caller",
-      ackAlreadySent: true,
-      ackReaction: makeAckReactionHandle(),
-    });
-
-    expect(maybeSendAckReactionMock).not.toHaveBeenCalled();
-  });
-
-  it("removes caller-provided ack after a successful visible reply", async () => {
-    const ackReaction = makeAckReactionHandle();
-
-    await processMessage({
-      ...makeRemoveAckAfterReplyParams(),
-      ackReaction,
-    });
-    await flushMicrotasks();
-
-    expect(ackReaction.remove).toHaveBeenCalledTimes(1);
-  });
-
-  it("removes internally sent ack after a successful visible reply", async () => {
-    const ackReaction = makeAckReactionHandle();
-    maybeSendAckReactionMock.mockResolvedValueOnce(ackReaction);
-
-    await processMessage(makeRemoveAckAfterReplyParams());
-    await flushMicrotasks();
-
-    expect(maybeSendAckReactionMock).toHaveBeenCalledTimes(1);
-    expect(ackReaction.remove).toHaveBeenCalledTimes(1);
-  });
-
-  it("keeps ack when no visible reply was delivered", async () => {
-    const ackReaction = makeAckReactionHandle();
-    maybeSendAckReactionMock.mockResolvedValueOnce(ackReaction);
-    vi.mocked(dispatchWhatsAppBufferedReply).mockResolvedValueOnce(false);
-
-    await processMessage(makeRemoveAckAfterReplyParams());
-    await flushMicrotasks();
-
-    expect(ackReaction.remove).not.toHaveBeenCalled();
-  });
-
-  it("keeps ack when the ack send failed", async () => {
-    const ackReaction = {
-      ...makeAckReactionHandle(),
-      ackReactionPromise: Promise.resolve(false),
-    };
-    maybeSendAckReactionMock.mockResolvedValueOnce(ackReaction);
-
-    await processMessage(makeRemoveAckAfterReplyParams());
-    await flushMicrotasks();
-
-    expect(ackReaction.remove).not.toHaveBeenCalled();
-  });
-
-  it("skips internal STT when preflightAudioTranscript is null (failed preflight sentinel)", async () => {
-    // null = caller already attempted preflight but got nothing (provider unavailable,
-    // disabled, etc.). processMessage must NOT retry to avoid 1+N attempts in broadcast.
-    await processMessage({
-      ...makeParams(),
-      preflightAudioTranscript: null,
-    });
-
-    expect(transcribeFirstAudioMock).not.toHaveBeenCalled();
-
-    // Body falls back to the original <media:audio> placeholder, not retried transcript.
-    const dispatchCall = vi.mocked(dispatchWhatsAppBufferedReply).mock.calls[0]?.[0];
-    expect(dispatchCall?.context).toMatchObject({
-      Body: "<media:audio>",
-    });
-  });
-});