@kodelyth/zalo 2026.5.42 → 2026.6.2

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

@@ -1,143 +0,0 @@
-import {
-  installChannelOutboundPayloadContractSuite,
-  primeChannelOutboundSendMock,
-  type OutboundPayloadHarnessParams,
-} from "klaw/plugin-sdk/channel-contract-testing";
-import {
-  createMessageReceiptFromOutboundResults,
-  verifyChannelMessageAdapterCapabilityProofs,
-} from "klaw/plugin-sdk/channel-message";
-import { describe, expect, it, vi } from "vitest";
-import { zaloMessageAdapter, zaloPlugin } from "./channel.js";
-
-const { sendZaloTextMock } = vi.hoisted(() => ({
-  sendZaloTextMock: vi.fn(),
-}));
-
-vi.mock("./channel.runtime.js", () => ({
-  sendZaloText: sendZaloTextMock,
-}));
-
-type ZaloOutbound = NonNullable<typeof zaloPlugin.outbound>;
-type ZaloSendPayload = NonNullable<ZaloOutbound["sendPayload"]>;
-type ZaloMessageSender = NonNullable<typeof zaloMessageAdapter.send>;
-
-function requireZaloSendPayload(): ZaloSendPayload {
-  const sendPayload = zaloPlugin.outbound?.sendPayload;
-  if (!sendPayload) {
-    throw new Error("Expected Zalo outbound sendPayload");
-  }
-  return sendPayload;
-}
-
-function requireZaloTextSender(): NonNullable<ZaloMessageSender["text"]> {
-  const text = zaloMessageAdapter.send?.text;
-  if (!text) {
-    throw new Error("Expected Zalo message adapter text sender");
-  }
-  return text;
-}
-
-function requireZaloMediaSender(): NonNullable<ZaloMessageSender["media"]> {
-  const media = zaloMessageAdapter.send?.media;
-  if (!media) {
-    throw new Error("Expected Zalo message adapter media sender");
-  }
-  return media;
-}
-
-function createZaloHarness(params: OutboundPayloadHarnessParams) {
-  const sendZalo = vi.fn();
-  primeChannelOutboundSendMock(sendZalo, { ok: true, messageId: "zl-1" }, params.sendResults);
-  sendZaloTextMock.mockReset().mockImplementation(
-    async (nextCtx: { to: string; text: string; mediaUrl?: string }) =>
-      await sendZalo(nextCtx.to, nextCtx.text, {
-        mediaUrl: nextCtx.mediaUrl,
-      }),
-  );
-  const ctx = {
-    cfg: {},
-    to: "123456789",
-    text: "",
-    payload: params.payload,
-  };
-  const sendPayload = requireZaloSendPayload();
-  return {
-    run: async () => await sendPayload(ctx),
-    sendMock: sendZalo,
-    to: ctx.to,
-  };
-}
-
-describe("Zalo outbound payload contract", () => {
-  installChannelOutboundPayloadContractSuite({
-    channel: "zalo",
-    chunking: { mode: "split", longTextLength: 3000, maxChunkLength: 2000 },
-    createHarness: createZaloHarness,
-  });
-
-  it("declares message adapter durable text and media with receipt proofs", async () => {
-    sendZaloTextMock.mockReset().mockImplementation(async (ctx: { mediaUrl?: string }) =>
-      ctx.mediaUrl
-        ? {
-            ok: true,
-            messageId: "zl-media-1",
-            receipt: createMessageReceiptFromOutboundResults({
-              results: [{ channel: "zalo", messageId: "zl-media-1" }],
-              kind: "media",
-            }),
-          }
-        : {
-            ok: true,
-            messageId: "zl-text-1",
-            receipt: createMessageReceiptFromOutboundResults({
-              results: [{ channel: "zalo", messageId: "zl-text-1" }],
-              kind: "text",
-            }),
-          },
-    );
-    const sendText = requireZaloTextSender();
-    const sendMedia = requireZaloMediaSender();
-
-    const proofs = await verifyChannelMessageAdapterCapabilityProofs({
-      adapterName: "zalo",
-      adapter: zaloMessageAdapter,
-      proofs: {
-        text: async () => {
-          const result = await sendText({
-            cfg: {},
-            to: "123456789",
-            text: "hello",
-          });
-          expect(result.receipt.platformMessageIds).toEqual(["zl-text-1"]);
-        },
-        media: async () => {
-          const result = await sendMedia({
-            cfg: {},
-            to: "123456789",
-            text: "image",
-            mediaUrl: "https://example.com/image.png",
-          });
-          expect(result.receipt.platformMessageIds).toEqual(["zl-media-1"]);
-        },
-        messageSendingHooks: () => {
-          expect(sendText).toBeTypeOf("function");
-        },
-      },
-    });
-    expect(proofs).toStrictEqual([
-      { capability: "text", status: "verified" },
-      { capability: "media", status: "verified" },
-      { capability: "payload", status: "not_declared" },
-      { capability: "silent", status: "not_declared" },
-      { capability: "replyTo", status: "not_declared" },
-      { capability: "thread", status: "not_declared" },
-      { capability: "nativeQuote", status: "not_declared" },
-      { capability: "messageSendingHooks", status: "verified" },
-      { capability: "batch", status: "not_declared" },
-      { capability: "reconcileUnknownSend", status: "not_declared" },
-      { capability: "afterSendSuccess", status: "not_declared" },
-      { capability: "afterCommit", status: "not_declared" },
-    ]);
-  });
-});

package/src/probe.ts

@@ -1,45 +0,0 @@
-import type { BaseProbeResult } from "klaw/plugin-sdk/channel-contract";
-import { getMe, ZaloApiError, type ZaloBotInfo, type ZaloFetch } from "./api.js";
-
-export type ZaloProbeResult = BaseProbeResult<string> & {
-  bot?: ZaloBotInfo;
-  elapsedMs: number;
-};
-
-export async function probeZalo(
-  token: string,
-  timeoutMs = 5000,
-  fetcher?: ZaloFetch,
-): Promise<ZaloProbeResult> {
-  if (!token?.trim()) {
-    return { ok: false, error: "No token provided", elapsedMs: 0 };
-  }
-
-  const startTime = Date.now();
-
-  try {
-    const response = await getMe(token.trim(), timeoutMs, fetcher);
-    const elapsedMs = Date.now() - startTime;
-
-    if (response.ok && response.result) {
-      return { ok: true, bot: response.result, elapsedMs };
-    }
-
-    return { ok: false, error: "Invalid response from Zalo API", elapsedMs };
-  } catch (err) {
-    const elapsedMs = Date.now() - startTime;
-
-    if (err instanceof ZaloApiError) {
-      return { ok: false, error: err.description ?? err.message, elapsedMs };
-    }
-
-    if (err instanceof Error) {
-      if (err.name === "AbortError") {
-        return { ok: false, error: `Request timed out after ${timeoutMs}ms`, elapsedMs };
-      }
-      return { ok: false, error: err.message, elapsedMs };
-    }
-
-    return { ok: false, error: String(err), elapsedMs };
-  }
-}

package/src/proxy.ts

@@ -1,18 +0,0 @@
-import { makeProxyFetch } from "klaw/plugin-sdk/fetch-runtime";
-import type { ZaloFetch } from "./api.js";
-
-const proxyCache = new Map<string, ZaloFetch>();
-
-export function resolveZaloProxyFetch(proxyUrl?: string | null): ZaloFetch | undefined {
-  const trimmed = proxyUrl?.trim();
-  if (!trimmed) {
-    return undefined;
-  }
-  const cached = proxyCache.get(trimmed);
-  if (cached) {
-    return cached;
-  }
-  const fetcher = makeProxyFetch(trimmed) as ZaloFetch;
-  proxyCache.set(trimmed, fetcher);
-  return fetcher;
-}

package/src/runtime-api.ts

@@ -1,71 +0,0 @@
-export {
-  addWildcardAllowFrom,
-  applyAccountNameToChannelSection,
-  applyBasicWebhookRequestGuards,
-  applySetupAccountConfigPatch,
-  type BaseProbeResult,
-  type BaseTokenResolution,
-  buildBaseAccountStatusSnapshot,
-  buildChannelConfigSchema,
-  buildSecretInputSchema,
-  buildSingleChannelSecretPromptState,
-  buildTokenChannelStatusSummary,
-  type ChannelAccountSnapshot,
-  type ChannelMessageActionAdapter,
-  type ChannelMessageActionName,
-  type ChannelPlugin,
-  type ChannelStatusIssue,
-  chunkTextForOutbound,
-  createChannelPairingController,
-  createChannelMessageReplyPipeline,
-  createDedupeCache,
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  DEFAULT_ACCOUNT_ID,
-  deliverTextOrMediaReply,
-  formatAllowFromLowercase,
-  formatPairingApproveHint,
-  type GroupPolicy,
-  hasConfiguredSecretInput,
-  isNormalizedSenderAllowed,
-  isNumericTargetId,
-  jsonResult,
-  logTypingFailure,
-  type MarkdownTableMode,
-  mergeAllowFromEntries,
-  migrateBaseNameToDefaultAccount,
-  normalizeAccountId,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-  type KlawConfig,
-  type OutboundReplyPayload,
-  PAIRING_APPROVED_MESSAGE,
-  type PluginRuntime,
-  promptSingleChannelSecretInput,
-  readJsonWebhookBodyOrReject,
-  readStringParam,
-  registerPluginHttpRoute,
-  type RegisterWebhookPluginRouteOptions,
-  registerWebhookTarget,
-  type RegisterWebhookTargetOptions,
-  registerWebhookTargetWithPluginRoute,
-  type ReplyPayload,
-  resolveClientIp,
-  resolveDefaultGroupPolicy,
-  resolveInboundRouteEnvelopeBuilderWithRuntime,
-  resolveOpenProviderRuntimeGroupPolicy,
-  resolveWebhookPath,
-  resolveWebhookTargetWithAuthOrRejectSync,
-  runSingleChannelSecretStep,
-  type RuntimeEnv,
-  type SecretInput,
-  sendPayloadWithChunkedTextAndMedia,
-  setTopLevelChannelDmPolicyWithAllowFrom,
-  waitForAbortSignal,
-  warnMissingProviderGroupPolicyFallbackOnce,
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS,
-  WEBHOOK_RATE_LIMIT_DEFAULTS,
-  withResolvedWebhookRequestPipeline,
-  type WizardPrompter,
-} from "./runtime-support.js";
-export { setZaloRuntime } from "./runtime.js";

package/src/runtime-support.ts

@@ -1,82 +0,0 @@
-export type { ReplyPayload } from "klaw/plugin-sdk/reply-runtime";
-export type { KlawConfig, GroupPolicy } from "klaw/plugin-sdk/config-contracts";
-export type { MarkdownTableMode } from "klaw/plugin-sdk/config-contracts";
-export type { BaseTokenResolution } from "klaw/plugin-sdk/channel-contract";
-export type {
-  BaseProbeResult,
-  ChannelAccountSnapshot,
-  ChannelMessageActionAdapter,
-  ChannelMessageActionName,
-  ChannelStatusIssue,
-} from "klaw/plugin-sdk/channel-contract";
-export type { SecretInput } from "klaw/plugin-sdk/secret-input";
-export type { ChannelPlugin, PluginRuntime, WizardPrompter } from "klaw/plugin-sdk/core";
-export type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-export type { OutboundReplyPayload } from "klaw/plugin-sdk/reply-payload";
-export {
-  DEFAULT_ACCOUNT_ID,
-  buildChannelConfigSchema,
-  createDedupeCache,
-  formatPairingApproveHint,
-  jsonResult,
-  normalizeAccountId,
-  readStringParam,
-  resolveClientIp,
-} from "klaw/plugin-sdk/core";
-export {
-  applyAccountNameToChannelSection,
-  applySetupAccountConfigPatch,
-  buildSingleChannelSecretPromptState,
-  mergeAllowFromEntries,
-  migrateBaseNameToDefaultAccount,
-  promptSingleChannelSecretInput,
-  runSingleChannelSecretStep,
-  setTopLevelChannelDmPolicyWithAllowFrom,
-} from "klaw/plugin-sdk/setup";
-export {
-  buildSecretInputSchema,
-  hasConfiguredSecretInput,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-} from "klaw/plugin-sdk/secret-input";
-export {
-  buildTokenChannelStatusSummary,
-  PAIRING_APPROVED_MESSAGE,
-} from "klaw/plugin-sdk/channel-status";
-export { buildBaseAccountStatusSnapshot } from "klaw/plugin-sdk/status-helpers";
-export { chunkTextForOutbound } from "klaw/plugin-sdk/text-chunking";
-export { formatAllowFromLowercase, isNormalizedSenderAllowed } from "klaw/plugin-sdk/allow-from";
-export { addWildcardAllowFrom } from "klaw/plugin-sdk/setup";
-export { resolveOpenProviderRuntimeGroupPolicy } from "klaw/plugin-sdk/runtime-group-policy";
-export {
-  warnMissingProviderGroupPolicyFallbackOnce,
-  resolveDefaultGroupPolicy,
-} from "klaw/plugin-sdk/runtime-group-policy";
-export { createChannelPairingController } from "klaw/plugin-sdk/channel-pairing";
-export { createChannelMessageReplyPipeline } from "klaw/plugin-sdk/channel-message";
-export { logTypingFailure } from "klaw/plugin-sdk/channel-feedback";
-export {
-  deliverTextOrMediaReply,
-  isNumericTargetId,
-  sendPayloadWithChunkedTextAndMedia,
-} from "klaw/plugin-sdk/reply-payload";
-export { resolveInboundRouteEnvelopeBuilderWithRuntime } from "klaw/plugin-sdk/inbound-envelope";
-export { waitForAbortSignal } from "klaw/plugin-sdk/runtime";
-export {
-  applyBasicWebhookRequestGuards,
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  readJsonWebhookBodyOrReject,
-  registerPluginHttpRoute,
-  registerWebhookTarget,
-  registerWebhookTargetWithPluginRoute,
-  resolveWebhookPath,
-  resolveWebhookTargetWithAuthOrRejectSync,
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS,
-  WEBHOOK_RATE_LIMIT_DEFAULTS,
-  withResolvedWebhookRequestPipeline,
-} from "klaw/plugin-sdk/webhook-ingress";
-export type {
-  RegisterWebhookPluginRouteOptions,
-  RegisterWebhookTargetOptions,
-} from "klaw/plugin-sdk/webhook-ingress";

package/src/runtime.ts

@@ -1,9 +0,0 @@
-import { createPluginRuntimeStore } from "klaw/plugin-sdk/runtime-store";
-import type { PluginRuntime } from "./runtime-support.js";
-
-const { setRuntime: setZaloRuntime, getRuntime: getZaloRuntime } =
-  createPluginRuntimeStore<PluginRuntime>({
-    pluginId: "zalo",
-    errorMessage: "Zalo runtime not initialized",
-  });
-export { getZaloRuntime, setZaloRuntime };

package/src/secret-contract.ts

@@ -1,109 +0,0 @@
-import {
-  collectConditionalChannelFieldAssignments,
-  getChannelSurface,
-  hasOwnProperty,
-  type ResolverContext,
-  type SecretDefaults,
-  type SecretTargetRegistryEntry,
-} from "klaw/plugin-sdk/channel-secret-basic-runtime";
-
-export const secretTargetRegistryEntries: SecretTargetRegistryEntry[] = [
-  {
-    id: "channels.zalo.accounts.*.botToken",
-    targetType: "channels.zalo.accounts.*.botToken",
-    configFile: "klaw.json",
-    pathPattern: "channels.zalo.accounts.*.botToken",
-    secretShape: "secret_input",
-    expectedResolvedValue: "string",
-    includeInPlan: true,
-    includeInConfigure: true,
-    includeInAudit: true,
-  },
-  {
-    id: "channels.zalo.accounts.*.webhookSecret",
-    targetType: "channels.zalo.accounts.*.webhookSecret",
-    configFile: "klaw.json",
-    pathPattern: "channels.zalo.accounts.*.webhookSecret",
-    secretShape: "secret_input",
-    expectedResolvedValue: "string",
-    includeInPlan: true,
-    includeInConfigure: true,
-    includeInAudit: true,
-  },
-  {
-    id: "channels.zalo.botToken",
-    targetType: "channels.zalo.botToken",
-    configFile: "klaw.json",
-    pathPattern: "channels.zalo.botToken",
-    secretShape: "secret_input",
-    expectedResolvedValue: "string",
-    includeInPlan: true,
-    includeInConfigure: true,
-    includeInAudit: true,
-  },
-  {
-    id: "channels.zalo.webhookSecret",
-    targetType: "channels.zalo.webhookSecret",
-    configFile: "klaw.json",
-    pathPattern: "channels.zalo.webhookSecret",
-    secretShape: "secret_input",
-    expectedResolvedValue: "string",
-    includeInPlan: true,
-    includeInConfigure: true,
-    includeInAudit: true,
-  },
-];
-
-export function collectRuntimeConfigAssignments(params: {
-  config: { channels?: Record<string, unknown> };
-  defaults?: SecretDefaults;
-  context: ResolverContext;
-}): void {
-  const resolved = getChannelSurface(params.config, "zalo");
-  if (!resolved) {
-    return;
-  }
-  const { channel: zalo, surface } = resolved;
-  collectConditionalChannelFieldAssignments({
-    channelKey: "zalo",
-    field: "botToken",
-    channel: zalo,
-    surface,
-    defaults: params.defaults,
-    context: params.context,
-    topLevelActiveWithoutAccounts: true,
-    topLevelInheritedAccountActive: ({ account, enabled }) =>
-      enabled && !hasOwnProperty(account, "botToken"),
-    accountActive: ({ enabled }) => enabled,
-    topInactiveReason: "no enabled Zalo surface inherits this top-level botToken.",
-    accountInactiveReason: "Zalo account is disabled.",
-  });
-  const baseWebhookUrl = typeof zalo.webhookUrl === "string" ? zalo.webhookUrl.trim() : "";
-  const accountWebhookUrl = (account: Record<string, unknown>) =>
-    hasOwnProperty(account, "webhookUrl")
-      ? typeof account.webhookUrl === "string"
-        ? account.webhookUrl.trim()
-        : ""
-      : baseWebhookUrl;
-  collectConditionalChannelFieldAssignments({
-    channelKey: "zalo",
-    field: "webhookSecret",
-    channel: zalo,
-    surface,
-    defaults: params.defaults,
-    context: params.context,
-    topLevelActiveWithoutAccounts: baseWebhookUrl.length > 0,
-    topLevelInheritedAccountActive: ({ account, enabled }) =>
-      enabled && !hasOwnProperty(account, "webhookSecret") && accountWebhookUrl(account).length > 0,
-    accountActive: ({ account, enabled }) => enabled && accountWebhookUrl(account).length > 0,
-    topInactiveReason:
-      "no enabled Zalo webhook surface inherits this top-level webhookSecret (webhook mode is not active).",
-    accountInactiveReason:
-      "Zalo account is disabled or webhook mode is not active for this account.",
-  });
-}
-
-export const channelSecrets = {
-  secretTargetRegistryEntries,
-  collectRuntimeConfigAssignments,
-};

package/src/secret-input.ts

@@ -1,5 +0,0 @@
-export {
-  buildSecretInputSchema,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-} from "klaw/plugin-sdk/secret-input";

package/src/send.test.ts

@@ -1,150 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const sendMessageMock = vi.fn();
-const sendPhotoMock = vi.fn();
-const resolveZaloProxyFetchMock = vi.fn();
-
-vi.mock("./api.js", () => ({
-  sendMessage: (...args: unknown[]) => sendMessageMock(...args),
-  sendPhoto: (...args: unknown[]) => sendPhotoMock(...args),
-}));
-
-vi.mock("./proxy.js", () => ({
-  resolveZaloProxyFetch: (...args: unknown[]) => resolveZaloProxyFetchMock(...args),
-}));
-
-import { sendMessageZalo, sendPhotoZalo } from "./send.js";
-
-type ZaloSendResult = Awaited<ReturnType<typeof sendMessageZalo>>;
-
-function requireSuccessfulSend(result: ZaloSendResult, expectedMessageId: string) {
-  expect(result.ok).toBe(true);
-  if (!result.ok) {
-    throw new Error(`expected successful Zalo send: ${result.error}`);
-  }
-  expect(result.messageId).toBe(expectedMessageId);
-  return result;
-}
-
-function expectFailedSend(result: ZaloSendResult, expectedError: string) {
-  expect(result.ok).toBe(false);
-  if (result.ok) {
-    throw new Error("expected failed Zalo send");
-  }
-  expect(result.error).toBe(expectedError);
-  expect(result.receipt.platformMessageIds).toStrictEqual([]);
-}
-
-describe("zalo send", () => {
-  beforeEach(() => {
-    sendMessageMock.mockReset();
-    sendPhotoMock.mockReset();
-    resolveZaloProxyFetchMock.mockReset();
-    resolveZaloProxyFetchMock.mockReturnValue(undefined);
-  });
-
-  it("sends text messages through the message API", async () => {
-    sendMessageMock.mockResolvedValueOnce({
-      ok: true,
-      result: { message_id: "z-msg-1" },
-    });
-
-    const result = await sendMessageZalo("dm-chat-1", "hello there", {
-      token: "zalo-token",
-    });
-
-    expect(sendMessageMock).toHaveBeenCalledWith(
-      "zalo-token",
-      {
-        chat_id: "dm-chat-1",
-        text: "hello there",
-      },
-      undefined,
-    );
-    expect(sendPhotoMock).not.toHaveBeenCalled();
-    const successful = requireSuccessfulSend(result, "z-msg-1");
-    expect(successful.receipt.primaryPlatformMessageId).toBe("z-msg-1");
-    expect(successful.receipt.platformMessageIds).toEqual(["z-msg-1"]);
-    expect(successful.receipt.parts).toHaveLength(1);
-    expect(successful.receipt.parts[0]?.platformMessageId).toBe("z-msg-1");
-    expect(successful.receipt.parts[0]?.kind).toBe("text");
-    expect(successful.receipt.parts[0]?.raw).toEqual({
-      channel: "zalo",
-      chatId: "dm-chat-1",
-      messageId: "z-msg-1",
-    });
-  });
-
-  it("routes media-bearing sends through the photo API and uses text as caption", async () => {
-    sendPhotoMock.mockResolvedValueOnce({
-      ok: true,
-      result: { message_id: "z-photo-1" },
-    });
-
-    const result = await sendMessageZalo("dm-chat-2", "caption text", {
-      token: "zalo-token",
-      mediaUrl: "https://example.com/photo.jpg",
-      caption: "ignored fallback caption",
-    });
-
-    expect(sendPhotoMock).toHaveBeenCalledWith(
-      "zalo-token",
-      {
-        chat_id: "dm-chat-2",
-        photo: "https://example.com/photo.jpg",
-        caption: "caption text",
-      },
-      undefined,
-    );
-    expect(sendMessageMock).not.toHaveBeenCalled();
-    const successful = requireSuccessfulSend(result, "z-photo-1");
-    expect(successful.receipt.primaryPlatformMessageId).toBe("z-photo-1");
-    expect(successful.receipt.platformMessageIds).toEqual(["z-photo-1"]);
-    expect(successful.receipt.parts).toHaveLength(1);
-    expect(successful.receipt.parts[0]?.platformMessageId).toBe("z-photo-1");
-    expect(successful.receipt.parts[0]?.kind).toBe("media");
-  });
-
-  it("fails fast for missing token or blank photo URLs", async () => {
-    const missingToken = await sendMessageZalo("dm-chat-3", "hello", {});
-    expectFailedSend(missingToken, "No Zalo bot token configured");
-
-    const blankPhoto = await sendPhotoZalo("dm-chat-4", "   ", {
-      token: "zalo-token",
-    });
-    expectFailedSend(blankPhoto, "No photo URL provided");
-
-    expect(sendMessageMock).not.toHaveBeenCalled();
-    expect(sendPhotoMock).not.toHaveBeenCalled();
-  });
-
-  it("sends cfg-backed media directly without hosted-media rewrites", async () => {
-    sendPhotoMock.mockResolvedValueOnce({
-      ok: true,
-      result: { message_id: "z-photo-2" },
-    });
-
-    const result = await sendPhotoZalo("dm-chat-5", "https://example.com/photo.jpg", {
-      cfg: {
-        channels: {
-          zalo: {
-            botToken: "zalo-token",
-            webhookUrl: "https://gateway.example.com/zalo-webhook",
-          },
-        },
-      } as never,
-    });
-
-    expect(sendPhotoMock).toHaveBeenCalledWith(
-      "zalo-token",
-      {
-        chat_id: "dm-chat-5",
-        photo: "https://example.com/photo.jpg",
-        caption: undefined,
-      },
-      undefined,
-    );
-    const successful = requireSuccessfulSend(result, "z-photo-2");
-    expect(successful.receipt.platformMessageIds).toEqual(["z-photo-2"]);
-  });
-});