@openclaw/zalo 2026.5.2 → 2026.5.3-beta.2

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

@@ -1,45 +0,0 @@
-import {
-  installChannelOutboundPayloadContractSuite,
-  primeChannelOutboundSendMock,
-  type OutboundPayloadHarnessParams,
-} from "openclaw/plugin-sdk/channel-contract-testing";
-import { describe, vi } from "vitest";
-import { zaloPlugin } from "./channel.js";
-
-const { sendZaloTextMock } = vi.hoisted(() => ({
-  sendZaloTextMock: vi.fn(),
-}));
-
-vi.mock("./channel.runtime.js", () => ({
-  sendZaloText: sendZaloTextMock,
-}));
-
-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,
-  };
-  return {
-    run: async () => await zaloPlugin.outbound!.sendPayload!(ctx),
-    sendMock: sendZalo,
-    to: ctx.to,
-  };
-}
-
-describe("Zalo outbound payload contract", () => {
-  installChannelOutboundPayloadContractSuite({
-    channel: "zalo",
-    chunking: { mode: "split", longTextLength: 3000, maxChunkLength: 2000 },
-    createHarness: createZaloHarness,
-  });
-});

package/src/probe.ts

@@ -1,45 +0,0 @@
-import type { BaseProbeResult } from "openclaw/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,24 +0,0 @@
-import type { RequestInit as UndiciRequestInit } from "undici";
-import { ProxyAgent, fetch as undiciFetch } from "undici";
-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 agent = new ProxyAgent(trimmed);
-  const fetcher: ZaloFetch = (input, init) =>
-    undiciFetch(input, {
-      ...init,
-      dispatcher: agent,
-    } as UndiciRequestInit) as unknown as Promise<Response>;
-  proxyCache.set(trimmed, fetcher);
-  return fetcher;
-}

package/src/runtime-api.ts

@@ -1,75 +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,
-  createChannelReplyPipeline,
-  createDedupeCache,
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  DEFAULT_ACCOUNT_ID,
-  deliverTextOrMediaReply,
-  evaluateSenderGroupAccess,
-  formatAllowFromLowercase,
-  formatPairingApproveHint,
-  type GroupPolicy,
-  hasConfiguredSecretInput,
-  isNormalizedSenderAllowed,
-  isNumericTargetId,
-  jsonResult,
-  logTypingFailure,
-  type MarkdownTableMode,
-  mergeAllowFromEntries,
-  migrateBaseNameToDefaultAccount,
-  normalizeAccountId,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-  type OpenClawConfig,
-  type OutboundReplyPayload,
-  PAIRING_APPROVED_MESSAGE,
-  type PluginRuntime,
-  promptSingleChannelSecretInput,
-  readJsonWebhookBodyOrReject,
-  readStringParam,
-  registerPluginHttpRoute,
-  type RegisterWebhookPluginRouteOptions,
-  registerWebhookTarget,
-  type RegisterWebhookTargetOptions,
-  registerWebhookTargetWithPluginRoute,
-  type ReplyPayload,
-  resolveClientIp,
-  resolveDefaultGroupPolicy,
-  resolveDirectDmAuthorizationOutcome,
-  resolveInboundRouteEnvelopeBuilderWithRuntime,
-  resolveOpenProviderRuntimeGroupPolicy,
-  resolveSenderCommandAuthorizationWithRuntime,
-  resolveWebhookPath,
-  resolveWebhookTargetWithAuthOrRejectSync,
-  runSingleChannelSecretStep,
-  type RuntimeEnv,
-  type SecretInput,
-  type SenderGroupAccessDecision,
-  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,91 +0,0 @@
-export type { ReplyPayload } from "openclaw/plugin-sdk/reply-runtime";
-export type { OpenClawConfig, GroupPolicy } from "openclaw/plugin-sdk/config-types";
-export type { MarkdownTableMode } from "openclaw/plugin-sdk/config-types";
-export type { BaseTokenResolution } from "openclaw/plugin-sdk/channel-contract";
-export type {
-  BaseProbeResult,
-  ChannelAccountSnapshot,
-  ChannelMessageActionAdapter,
-  ChannelMessageActionName,
-  ChannelStatusIssue,
-} from "openclaw/plugin-sdk/channel-contract";
-export type { SecretInput } from "openclaw/plugin-sdk/secret-input";
-export type { SenderGroupAccessDecision } from "openclaw/plugin-sdk/group-access";
-export type { ChannelPlugin, PluginRuntime, WizardPrompter } from "openclaw/plugin-sdk/core";
-export type { RuntimeEnv } from "openclaw/plugin-sdk/runtime";
-export type { OutboundReplyPayload } from "openclaw/plugin-sdk/reply-payload";
-export {
-  DEFAULT_ACCOUNT_ID,
-  buildChannelConfigSchema,
-  createDedupeCache,
-  formatPairingApproveHint,
-  jsonResult,
-  normalizeAccountId,
-  readStringParam,
-  resolveClientIp,
-} from "openclaw/plugin-sdk/core";
-export {
-  applyAccountNameToChannelSection,
-  applySetupAccountConfigPatch,
-  buildSingleChannelSecretPromptState,
-  mergeAllowFromEntries,
-  migrateBaseNameToDefaultAccount,
-  promptSingleChannelSecretInput,
-  runSingleChannelSecretStep,
-  setTopLevelChannelDmPolicyWithAllowFrom,
-} from "openclaw/plugin-sdk/setup";
-export {
-  buildSecretInputSchema,
-  hasConfiguredSecretInput,
-  normalizeResolvedSecretInputString,
-  normalizeSecretInputString,
-} from "openclaw/plugin-sdk/secret-input";
-export {
-  buildTokenChannelStatusSummary,
-  PAIRING_APPROVED_MESSAGE,
-} from "openclaw/plugin-sdk/channel-status";
-export { buildBaseAccountStatusSnapshot } from "openclaw/plugin-sdk/status-helpers";
-export { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-export {
-  formatAllowFromLowercase,
-  isNormalizedSenderAllowed,
-} from "openclaw/plugin-sdk/allow-from";
-export { addWildcardAllowFrom } from "openclaw/plugin-sdk/setup";
-export { evaluateSenderGroupAccess } from "openclaw/plugin-sdk/group-access";
-export { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
-export {
-  warnMissingProviderGroupPolicyFallbackOnce,
-  resolveDefaultGroupPolicy,
-} from "openclaw/plugin-sdk/runtime-group-policy";
-export { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
-export { createChannelReplyPipeline } from "openclaw/plugin-sdk/channel-reply-pipeline";
-export { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
-export {
-  deliverTextOrMediaReply,
-  isNumericTargetId,
-  sendPayloadWithChunkedTextAndMedia,
-} from "openclaw/plugin-sdk/reply-payload";
-export {
-  resolveDirectDmAuthorizationOutcome,
-  resolveSenderCommandAuthorizationWithRuntime,
-} from "openclaw/plugin-sdk/command-auth";
-export { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
-export { waitForAbortSignal } from "openclaw/plugin-sdk/runtime";
-export {
-  applyBasicWebhookRequestGuards,
-  createFixedWindowRateLimiter,
-  createWebhookAnomalyTracker,
-  readJsonWebhookBodyOrReject,
-  registerPluginHttpRoute,
-  registerWebhookTarget,
-  registerWebhookTargetWithPluginRoute,
-  resolveWebhookPath,
-  resolveWebhookTargetWithAuthOrRejectSync,
-  WEBHOOK_ANOMALY_COUNTER_DEFAULTS,
-  WEBHOOK_RATE_LIMIT_DEFAULTS,
-  withResolvedWebhookRequestPipeline,
-} from "openclaw/plugin-sdk/webhook-ingress";
-export type {
-  RegisterWebhookPluginRouteOptions,
-  RegisterWebhookTargetOptions,
-} from "openclaw/plugin-sdk/webhook-ingress";

package/src/runtime.ts

@@ -1,9 +0,0 @@
-import { createPluginRuntimeStore } from "openclaw/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 "openclaw/plugin-sdk/channel-secret-basic-runtime";
-
-export const secretTargetRegistryEntries: SecretTargetRegistryEntry[] = [
-  {
-    id: "channels.zalo.accounts.*.botToken",
-    targetType: "channels.zalo.accounts.*.botToken",
-    configFile: "openclaw.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: "openclaw.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: "openclaw.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: "openclaw.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 "openclaw/plugin-sdk/secret-input";

package/src/send.test.ts

@@ -1,120 +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";
-
-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();
-    expect(result).toEqual({ ok: true, 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();
-    expect(result).toEqual({ ok: true, messageId: "z-photo-1" });
-  });
-
-  it("fails fast for missing token or blank photo URLs", async () => {
-    await expect(sendMessageZalo("dm-chat-3", "hello", {})).resolves.toEqual({
-      ok: false,
-      error: "No Zalo bot token configured",
-    });
-
-    await expect(
-      sendPhotoZalo("dm-chat-4", "   ", {
-        token: "zalo-token",
-      }),
-    ).resolves.toEqual({
-      ok: false,
-      error: "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,
-    );
-    expect(result).toEqual({ ok: true, messageId: "z-photo-2" });
-  });
-});

package/src/send.ts

@@ -1,153 +0,0 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
-import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
-import { resolveZaloAccount } from "./accounts.js";
-import type { ZaloFetch } from "./api.js";
-import { sendMessage, sendPhoto } from "./api.js";
-import { resolveZaloProxyFetch } from "./proxy.js";
-import { resolveZaloToken } from "./token.js";
-
-type ZaloSendOptions = {
-  token?: string;
-  accountId?: string;
-  cfg?: OpenClawConfig;
-  mediaUrl?: string;
-  caption?: string;
-  verbose?: boolean;
-  proxy?: string;
-};
-
-type ZaloSendResult = {
-  ok: boolean;
-  messageId?: string;
-  error?: string;
-};
-
-function toZaloSendResult(response: {
-  ok?: boolean;
-  result?: { message_id?: string };
-}): ZaloSendResult {
-  if (response.ok && response.result) {
-    return { ok: true, messageId: response.result.message_id };
-  }
-  return { ok: false, error: "Failed to send message" };
-}
-
-async function runZaloSend(
-  failureMessage: string,
-  send: () => Promise<{ ok?: boolean; result?: { message_id?: string } }>,
-): Promise<ZaloSendResult> {
-  try {
-    const result = toZaloSendResult(await send());
-    return result.ok ? result : { ok: false, error: failureMessage };
-  } catch (err) {
-    return { ok: false, error: formatErrorMessage(err) };
-  }
-}
-
-function resolveSendContext(options: ZaloSendOptions): {
-  token: string;
-  fetcher?: ZaloFetch;
-} {
-  if (options.cfg) {
-    const account = resolveZaloAccount({
-      cfg: options.cfg,
-      accountId: options.accountId,
-    });
-    const token = options.token || account.token;
-    const proxy = options.proxy ?? account.config.proxy;
-    return { token, fetcher: resolveZaloProxyFetch(proxy) };
-  }
-
-  const token = options.token ?? resolveZaloToken(undefined, options.accountId).token;
-  const proxy = options.proxy;
-  return { token, fetcher: resolveZaloProxyFetch(proxy) };
-}
-
-function resolveValidatedSendContext(
-  chatId: string,
-  options: ZaloSendOptions,
-): { ok: true; chatId: string; token: string; fetcher?: ZaloFetch } | { ok: false; error: string } {
-  const { token, fetcher } = resolveSendContext(options);
-  if (!token) {
-    return { ok: false, error: "No Zalo bot token configured" };
-  }
-  const trimmedChatId = chatId?.trim();
-  if (!trimmedChatId) {
-    return { ok: false, error: "No chat_id provided" };
-  }
-  return { ok: true, chatId: trimmedChatId, token, fetcher };
-}
-
-function resolveSendContextOrFailure(
-  chatId: string,
-  options: ZaloSendOptions,
-):
-  | { context: { chatId: string; token: string; fetcher?: ZaloFetch } }
-  | { failure: ZaloSendResult } {
-  const context = resolveValidatedSendContext(chatId, options);
-  return context.ok
-    ? { context }
-    : {
-        failure: { ok: false, error: context.error },
-      };
-}
-
-export async function sendMessageZalo(
-  chatId: string,
-  text: string,
-  options: ZaloSendOptions = {},
-): Promise<ZaloSendResult> {
-  const resolved = resolveSendContextOrFailure(chatId, options);
-  if ("failure" in resolved) {
-    return resolved.failure;
-  }
-  const { context } = resolved;
-
-  if (options.mediaUrl) {
-    return sendPhotoZalo(context.chatId, options.mediaUrl, {
-      ...options,
-      token: context.token,
-      caption: text || options.caption,
-    });
-  }
-
-  return await runZaloSend("Failed to send message", () =>
-    sendMessage(
-      context.token,
-      {
-        chat_id: context.chatId,
-        text: text.slice(0, 2000),
-      },
-      context.fetcher,
-    ),
-  );
-}
-
-export async function sendPhotoZalo(
-  chatId: string,
-  photoUrl: string,
-  options: ZaloSendOptions = {},
-): Promise<ZaloSendResult> {
-  const resolved = resolveSendContextOrFailure(chatId, options);
-  if ("failure" in resolved) {
-    return resolved.failure;
-  }
-  const { context } = resolved;
-
-  if (!photoUrl?.trim()) {
-    return { ok: false, error: "No photo URL provided" };
-  }
-
-  return await runZaloSend("Failed to send photo", () =>
-    (async () =>
-      sendPhoto(
-        context.token,
-        {
-          chat_id: context.chatId,
-          photo: photoUrl.trim(),
-          caption: options.caption?.slice(0, 2000),
-        },
-        context.fetcher,
-      ))(),
-  );
-}