@openclaw/zalo 2026.7.2-beta.3 → 2026.7.2-beta.4

package/dist/{actions.runtime-OmfJFYZn.js → actions.runtime-DwjVG1H3.js}

@@ -1,4 +1,4 @@
-import { t as sendMessageZalo } from "./send-9sVVxyap.js";
+import { t as sendMessageZalo } from "./send-WPSy5EgF.js";
 //#region extensions/zalo/src/actions.runtime.ts
 const zaloActionsRuntime = { sendMessageZalo };
 //#endregion

package/dist/api.js

@@ -1,5 +1,5 @@
-import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-fwCh0QUi.js";
-import { t as zaloPlugin } from "./channel-DikWJ2TC.js";
+import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-BBA-V-j0.js";
+import { t as zaloPlugin } from "./channel-CvZItLo-.js";
 import { n as resolveZaloRuntimeGroupPolicy } from "./group-access-8qHRzDHx.js";
 import { zaloSetupWizard } from "./setup-api.js";
 export { createZaloSetupWizardProxy, resolveZaloRuntimeGroupPolicy, zaloDmPolicy, zaloPlugin, zaloSetupAdapter, zaloSetupWizard };

package/dist/{channel-DikWJ2TC.js → channel-CvZItLo-.js}

@@ -1,4 +1,4 @@
-import { c as listZaloAccountIds, f as buildSecretInputSchema, l as resolveDefaultZaloAccountId, r as zaloSetupAdapter, s as listEnabledZaloAccounts, t as createZaloSetupWizardProxy, u as resolveZaloAccount } from "./setup-core-fwCh0QUi.js";
+import { c as listEnabledZaloAccounts, d as resolveZaloAccount, i as zaloSetupContract, l as listZaloAccountIds, p as buildSecretInputSchema, r as zaloSetupAdapter, t as createZaloSetupWizardProxy, u as resolveDefaultZaloAccountId } from "./setup-core-BBA-V-j0.js";
 import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-Bxvjh0Hq.js";
 import { describeWebhookAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
 import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
@@ -14,7 +14,7 @@ import { createChannelDirectoryAdapter, listResolvedDirectoryUserEntriesFromAllo
 import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import { sendPayloadWithChunkedTextAndMedia } from "openclaw/plugin-sdk/reply-payload";
 import { createComputedAccountStatusAdapter, createDefaultChannelRuntimeState, standardDmPolicyOpenIssue } from "openclaw/plugin-sdk/status-helpers";
-import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
+import { chunkTextForOutbound, sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
 import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { buildChannelOutboundSessionRoute, stripChannelTargetPrefix, stripTargetKindPrefix } from "openclaw/plugin-sdk/core";
 import { jsonResult, readStringParam } from "openclaw/plugin-sdk/channel-actions";
@@ -24,7 +24,7 @@ import { AllowFromListSchema, DmPolicySchema, GroupPolicySchema, MarkdownConfigS
 import { z } from "zod";
 import { coerceStatusIssueAccountId, readStatusIssueFields } from "openclaw/plugin-sdk/extension-shared";
 //#region extensions/zalo/src/actions.ts
-const loadZaloActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-OmfJFYZn.js"), "zaloActionsRuntime");
+const loadZaloActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-DwjVG1H3.js"), "zaloActionsRuntime");
 const providerId = "zalo";
 const ZALO_ACTIONS = /* @__PURE__ */ new Set(["send"]);
 function listEnabledAccounts(cfg, accountId) {
@@ -176,8 +176,8 @@ function looksLikeZaloChatId(raw, normalized) {
 	const target = normalizeZaloMessagingTarget(normalized ?? raw);
 	return Boolean(target);
 }
-const loadZaloChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-DrCGqgEo.js"));
-const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-8eRimod9.js")).zaloSetupWizard);
+const loadZaloChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-U7gDleS5.js"));
+const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-dFkadq_c.js")).zaloSetupWizard);
 const zaloTextChunkLimit = 2e3;
 async function sendZaloDelivery(ctx) {
 	const result = await (await loadZaloChannelRuntime()).sendZaloText({
@@ -258,6 +258,7 @@ const zaloPlugin = createChatChannelPlugin({
 		id: "zalo",
 		meta,
 		setup: zaloSetupAdapter,
+		setupContract: zaloSetupContract,
 		setupWizard: zaloSetupWizard,
 		capabilities: {
 			chatTypes: ["direct", "group"],
@@ -347,6 +348,7 @@ const zaloPlugin = createChatChannelPlugin({
 		chunker: chunkTextForOutbound,
 		chunkerMode: "text",
 		textChunkLimit: zaloTextChunkLimit,
+		sanitizeText: ({ text }) => sanitizeAssistantVisibleText(text),
 		sendPayload: async (ctx) => await sendPayloadWithChunkedTextAndMedia({
 			ctx,
 			textChunkLimit: zaloTextChunkLimit,

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as zaloPlugin } from "./channel-DikWJ2TC.js";
+import { t as zaloPlugin } from "./channel-CvZItLo-.js";
 export { zaloPlugin };

package/dist/{channel.runtime-DrCGqgEo.js → channel.runtime-U7gDleS5.js}

@@ -1,6 +1,6 @@
-import { p as normalizeSecretInputString } from "./setup-core-fwCh0QUi.js";
+import { m as normalizeSecretInputString } from "./setup-core-BBA-V-j0.js";
 import { i as PAIRING_APPROVED_MESSAGE } from "./runtime-api-B53PGWBW.js";
-import { a as getMe, n as resolveZaloProxyFetch, r as ZaloApiError, t as sendMessageZalo } from "./send-9sVVxyap.js";
+import { a as getMe, n as resolveZaloProxyFetch, r as ZaloApiError, t as sendMessageZalo } from "./send-WPSy5EgF.js";
 import { createAccountStatusSink } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/zalo/src/probe.ts
 async function probeZalo(token, timeoutMs = 5e3, fetcher) {
@@ -52,7 +52,7 @@ async function probeZalo(token, timeoutMs = 5e3, fetcher) {
 //#endregion
 //#region extensions/zalo/src/channel.runtime.ts
 async function notifyZaloPairingApproval(params) {
-	const { resolveZaloAccount } = await import("./setup-core-fwCh0QUi.js").then((n) => n.o);
+	const { resolveZaloAccount } = await import("./setup-core-BBA-V-j0.js").then((n) => n.s);
 	const account = resolveZaloAccount({ cfg: params.cfg });
 	if (!account.token) throw new Error("Zalo token not configured");
 	await sendMessageZalo(params.id, PAIRING_APPROVED_MESSAGE, { token: account.token });
@@ -86,7 +86,7 @@ async function startZaloGatewayAccount(ctx) {
 		setStatus: ctx.setStatus
 	});
 	ctx.log?.info(`[${account.accountId}] starting provider${zaloBotLabel} mode=${mode}`);
-	const { monitorZaloProvider } = await import("./monitor-oEpn3pC7.js");
+	const { monitorZaloProvider } = await import("./monitor-DfHhlqTv.js");
 	return monitorZaloProvider({
 		token,
 		account,

package/dist/{monitor-oEpn3pC7.js → monitor-DfHhlqTv.js}

@@ -1,7 +1,7 @@
 import { n as resolveZaloRuntimeGroupPolicy, t as normalizeZaloAllowEntry } from "./group-access-8qHRzDHx.js";
 import { t as getZaloRuntime } from "./runtime-api-B53PGWBW.js";
-import { c as sendChatAction, d as setWebhook, i as deleteWebhook, l as sendMessage, n as resolveZaloProxyFetch, o as getUpdates, r as ZaloApiError, s as getWebhookInfo, u as sendPhoto } from "./send-9sVVxyap.js";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { c as sendChatAction, d as setWebhook, f as ZALO_OUTBOUND_MEDIA_TTL_MS, i as deleteWebhook, l as sendMessage, n as resolveZaloProxyFetch, o as getUpdates, r as ZaloApiError, s as getWebhookInfo, u as sendPhoto } from "./send-WPSy5EgF.js";
+import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
 import { deliverTextOrMediaReply, resolveSendableOutboundReplyParts } from "openclaw/plugin-sdk/reply-payload";
 import { normalizeStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
@@ -30,7 +30,6 @@ function resolveZaloDurableReplyOptions(params) {
 }
 //#endregion
 //#region extensions/zalo/src/outbound-media.ts
-const ZALO_OUTBOUND_MEDIA_TTL_MS = 2 * 6e4;
 const ZALO_OUTBOUND_MEDIA_SEGMENT = "media";
 const ZALO_OUTBOUND_MEDIA_PREFIX = `/${ZALO_OUTBOUND_MEDIA_SEGMENT}/`;
 const ZALO_OUTBOUND_MEDIA_ID_RE = /^[a-f0-9]{24}$/;
@@ -74,7 +73,7 @@ function resolveHostedZaloMediaRoutePath(params) {
 }
 async function prepareHostedZaloMediaUrl(params) {
 	const now = asDateTimestampMs(Date.now());
-	if ((now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(ZALO_OUTBOUND_MEDIA_TTL_MS, { nowMs: now })) === void 0) throw new Error("Zalo outbound media expiry could not be resolved");
+	if ((now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(12e4, { nowMs: now })) === void 0) throw new Error("Zalo outbound media expiry could not be resolved");
 	const routePath = resolveHostedZaloMediaRoutePath({
 		webhookUrl: params.webhookUrl,
 		webhookPath: params.webhookPath
@@ -164,7 +163,12 @@ function resolveZaloTimestampMs(date) {
 	if (!date) return;
 	return date >= UNIX_MILLISECONDS_THRESHOLD ? date : date * 1e3;
 }
-const loadZaloWebhookModule = createLazyRuntimeModule(() => import("./monitor.webhook-CiT0mp4W.js"));
+const loadZaloWebhookRuntime = createLazyRuntimeNamedExport(() => import("./monitor.webhook-BCTmWQY8.js"), "zaloWebhookRuntime");
+const loadZaloWebhookIngressRuntime = createLazyRuntimeNamedExport(() => import("./webhook-spool-Ozf0tcbs.js"), "zaloWebhookIngressRuntime");
+const loadZaloWebhookModule = createLazyRuntimeModule(async () => ({
+	...await loadZaloWebhookRuntime(),
+	...await loadZaloWebhookIngressRuntime()
+}));
 function releaseSharedHostedMediaRouteRef(routePath) {
 	const current = hostedMediaRouteRefs.get(routePath);
 	if (!current) return;
@@ -225,22 +229,7 @@ function logVerbose(core, runtime, message) {
 }
 async function handleZaloWebhookRequest(req, res) {
 	const { handleZaloWebhookRequest: handleZaloWebhookRequestInternal } = await loadZaloWebhookModule();
-	return await handleZaloWebhookRequestInternal(req, res, async ({ update, target }) => {
-		await processUpdate({
-			update,
-			token: target.token,
-			account: target.account,
-			config: target.config,
-			runtime: target.runtime,
-			core: target.core,
-			mediaMaxMb: target.mediaMaxMb,
-			canHostMedia: target.canHostMedia,
-			webhookUrl: target.webhookUrl,
-			webhookPath: target.webhookPath,
-			statusSink: target.statusSink,
-			fetcher: target.fetcher
-		});
-	});
+	return await handleZaloWebhookRequestInternal(req, res);
 }
 function startPollingLoop(params) {
 	const { token, account, config, runtime, core, mediaMaxMb, canHostMedia, webhookUrl, webhookPath, abortSignal, isStopped, statusSink, fetcher } = params;
@@ -297,7 +286,8 @@ async function processUpdate(params) {
 		webhookUrl: params.webhookUrl,
 		webhookPath: params.webhookPath,
 		statusSink,
-		fetcher
+		fetcher,
+		turnAdoptionLifecycle: params.turnAdoptionLifecycle
 	};
 	if (!message) return;
 	switch (event_name) {
@@ -329,6 +319,7 @@ async function handleTextMessage(params) {
 	await processMessageWithPipeline({
 		...params,
 		text,
+		mediaKind: void 0,
 		mediaPath: void 0,
 		mediaType: void 0
 	});
@@ -339,7 +330,8 @@ async function handleImageMessage(params) {
 	const authorization = await authorizeZaloMessage({
 		...params,
 		text: caption,
-		mediaPath: "__pending_media__",
+		mediaKind: "image",
+		mediaPath: void 0,
 		mediaType: void 0
 	});
 	if (!authorization) return;
@@ -359,21 +351,21 @@ async function handleImageMessage(params) {
 		runtime.error?.(`[${account.accountId}] Failed to download Zalo image: ${String(err)}`);
 	}
 	const agentBody = mediaPath ? authorization.rawBody : formatInboundMediaUnavailableText({
-		body: caption,
-		mediaPlaceholder: "<media:image>",
+		body: authorization.rawBody,
 		notice: "[zalo image attachment unavailable]"
 	});
 	await processMessageWithPipeline({
 		...params,
 		authorization,
 		agentBody,
+		mediaKind: "image",
 		text: caption,
 		mediaPath,
 		mediaType
 	});
 }
 async function authorizeZaloMessage(params) {
-	const { message, account, config, runtime, core, text, mediaPath, token, statusSink, fetcher } = params;
+	const { message, account, config, runtime, core, text, token, statusSink, fetcher } = params;
 	const pairing = createChannelPairingController({
 		core,
 		channel: "zalo",
@@ -386,7 +378,7 @@ async function authorizeZaloMessage(params) {
 	const senderName = from.display_name ?? from.name;
 	const dmPolicy = account.config.dmPolicy ?? "pairing";
 	const defaultGroupPolicy = resolveDefaultGroupPolicy(config);
-	const rawBody = text?.trim() || (mediaPath ? "<media:image>" : "");
+	const rawBody = text?.trim() ?? "";
 	const { groupPolicy, providerMissingFallbackApplied } = resolveZaloRuntimeGroupPolicy({
 		providerConfigPresent: config.channels?.zalo !== void 0,
 		groupPolicy: account.config.groupPolicy,
@@ -468,7 +460,7 @@ async function authorizeZaloMessage(params) {
 	};
 }
 async function processMessageWithPipeline(params) {
-	const { message, token, account, config, runtime, core, mediaPath, mediaType, statusSink, fetcher, agentBody: agentBodyOverride, authorization: authorizationOverride } = params;
+	const { message, token, account, config, runtime, core, mediaPath, mediaKind, mediaType, statusSink, fetcher, agentBody: agentBodyOverride, authorization: authorizationOverride } = params;
 	const { message_id, date } = message;
 	const authorization = authorizationOverride ?? await authorizeZaloMessage({
 		...params,
@@ -527,10 +519,11 @@ async function processMessageWithPipeline(params) {
 			rawBody,
 			commandBody: rawBody
 		},
-		media: mediaPath || mediaType ? [{
+		media: mediaKind || mediaPath || mediaType ? [{
 			path: mediaPath,
 			url: mediaPath,
-			contentType: mediaType
+			contentType: mediaType,
+			kind: mediaKind ?? void 0
 		}] : void 0,
 		extra: {
 			CommandAuthorized: commandAuthorized,
@@ -608,7 +601,8 @@ async function processMessageWithPipeline(params) {
 		} },
 		record: { onRecordError: (err) => {
 			runtime.error?.(`zalo: failed updating session meta: ${String(err)}`);
-		} }
+		} },
+		...params.turnAdoptionLifecycle ? { turnAdoptionLifecycle: params.turnAdoptionLifecycle } : {}
 	});
 }
 async function deliverZaloReply(params) {
@@ -670,6 +664,7 @@ async function monitorZaloProvider(options) {
 	}) : void 0;
 	let stopped = false;
 	const stopHandlers = [];
+	const asyncStopHandlers = [];
 	let cleanupWebhook;
 	const stop = () => {
 		if (stopped) return;
@@ -691,46 +686,44 @@ async function monitorZaloProvider(options) {
 			stopHandlers.push(unregisterHostedMediaRoute);
 		}
 		if (useWebhook) {
-			const { registerZaloWebhookTarget } = await loadZaloWebhookModule();
+			const { createZaloWebhookIngress, registerZaloWebhookTarget } = await loadZaloWebhookModule();
 			if (!effectiveWebhookUrl || !webhookSecret) throw new Error("Zalo webhookUrl and webhookSecret are required for webhook mode");
 			if (!effectiveWebhookUrl.startsWith("https://")) throw new Error("Zalo webhook URL must use HTTPS");
 			if (webhookSecret.length < 8 || webhookSecret.length > 256) throw new Error("Zalo webhook secret must be 8-256 characters");
 			const path = effectiveWebhookPath;
 			if (!path) throw new Error("Zalo webhookPath could not be derived");
 			runtime.log?.(`[${account.accountId}] Zalo configuring webhook path=${path} target=${describeWebhookTarget(effectiveWebhookUrl)}`);
-			await setWebhook(token, {
-				url: effectiveWebhookUrl,
-				secret_token: webhookSecret
-			}, fetcher);
-			let webhookCleanupPromise;
-			cleanupWebhook = async () => {
-				if (!webhookCleanupPromise) webhookCleanupPromise = (async () => {
-					runtime.log?.(`[${account.accountId}] Zalo stopping; deleting webhook`);
-					try {
-						await deleteWebhook(token, fetcher, WEBHOOK_CLEANUP_TIMEOUT_MS);
-						runtime.log?.(`[${account.accountId}] Zalo webhook deleted`);
-					} catch (err) {
-						const detail = err instanceof Error && err.name === "AbortError" ? `timed out after ${String(WEBHOOK_CLEANUP_TIMEOUT_MS)}ms` : formatZaloError(err);
-						runtime.error?.(`[${account.accountId}] Zalo webhook delete failed: ${detail}`);
-					}
-				})();
-				await webhookCleanupPromise;
-			};
-			runtime.log?.(`[${account.accountId}] Zalo webhook registered path=${path}`);
+			const ingress = createZaloWebhookIngress({
+				accountId: account.accountId,
+				runtime,
+				deliver: async (update, turnAdoptionLifecycle) => {
+					statusSink?.({ lastInboundAt: Date.now() });
+					await processUpdate({
+						update,
+						token,
+						account,
+						config,
+						runtime,
+						core,
+						mediaMaxMb: effectiveMediaMaxMb,
+						canHostMedia,
+						webhookUrl: effectiveWebhookUrl,
+						webhookPath: path,
+						statusSink,
+						fetcher,
+						turnAdoptionLifecycle
+					});
+				}
+			});
+			ingress.start();
+			asyncStopHandlers.push(ingress.stop);
 			const unregister = registerZaloWebhookTarget({
-				token,
 				account,
 				config,
 				runtime,
-				core,
 				path,
-				webhookUrl: effectiveWebhookUrl,
-				webhookPath: path,
 				secret: webhookSecret,
-				statusSink: (patch) => statusSink?.(patch),
-				mediaMaxMb: effectiveMediaMaxMb,
-				canHostMedia,
-				fetcher
+				acceptWebhook: ingress.accept
 			}, { route: {
 				auth: "plugin",
 				match: "exact",
@@ -747,6 +740,25 @@ async function monitorZaloProvider(options) {
 				}
 			} });
 			stopHandlers.push(unregister);
+			await setWebhook(token, {
+				url: effectiveWebhookUrl,
+				secret_token: webhookSecret
+			}, fetcher);
+			let webhookCleanupPromise;
+			cleanupWebhook = async () => {
+				if (!webhookCleanupPromise) webhookCleanupPromise = (async () => {
+					runtime.log?.(`[${account.accountId}] Zalo stopping; deleting webhook`);
+					try {
+						await deleteWebhook(token, fetcher, WEBHOOK_CLEANUP_TIMEOUT_MS);
+						runtime.log?.(`[${account.accountId}] Zalo webhook deleted`);
+					} catch (err) {
+						const detail = err instanceof Error && err.name === "AbortError" ? `timed out after ${String(WEBHOOK_CLEANUP_TIMEOUT_MS)}ms` : formatZaloError(err);
+						runtime.error?.(`[${account.accountId}] Zalo webhook delete failed: ${detail}`);
+					}
+				})();
+				await webhookCleanupPromise;
+			};
+			runtime.log?.(`[${account.accountId}] Zalo webhook registered path=${path}`);
 			await waitForAbortSignal(abortSignal);
 			return;
 		}
@@ -790,6 +802,7 @@ async function monitorZaloProvider(options) {
 		abortSignal.removeEventListener("abort", stopOnAbort);
 		await cleanupWebhook?.();
 		stop();
+		for (const stopAsync of asyncStopHandlers) await stopAsync();
 		runtime.log?.(`[${account.accountId}] Zalo provider stopped mode=${mode}`);
 	}
 }

package/dist/{monitor.webhook-CiT0mp4W.js → monitor.webhook-BCTmWQY8.js}

@@ -1,9 +1,8 @@
-import { B as registerWebhookTargetWithPluginRoute, G as resolveWebhookTargetWithAuthOrRejectSync, I as readJsonWebhookBodyOrReject, V as resolveClientIp, Z as withResolvedWebhookRequestPipeline, a as WEBHOOK_ANOMALY_COUNTER_DEFAULTS, b as createFixedWindowRateLimiter, l as applyBasicWebhookRequestGuards, o as WEBHOOK_RATE_LIMIT_DEFAULTS, x as createWebhookAnomalyTracker, z as registerWebhookTarget } from "./runtime-api-B53PGWBW.js";
+import { B as registerWebhookTargetWithPluginRoute, G as resolveWebhookTargetWithAuthOrRejectSync, V as resolveClientIp, Z as withResolvedWebhookRequestPipeline, a as WEBHOOK_ANOMALY_COUNTER_DEFAULTS, b as createFixedWindowRateLimiter, l as applyBasicWebhookRequestGuards, o as WEBHOOK_RATE_LIMIT_DEFAULTS, x as createWebhookAnomalyTracker, z as registerWebhookTarget } from "./runtime-api-B53PGWBW.js";
+import { ZaloWebhookPayloadError } from "./webhook-spool-Ozf0tcbs.js";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
-import { createChannelReplayGuard } from "openclaw/plugin-sdk/persistent-dedupe";
-import { runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
+import { readWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
 //#region extensions/zalo/src/monitor.webhook.ts
-const ZALO_WEBHOOK_REPLAY_WINDOW_MS = 5 * 6e4;
 const webhookTargets = /* @__PURE__ */ new Map();
 const webhookRateLimiter = createFixedWindowRateLimiter({
 	windowMs: WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs,
@@ -17,7 +16,6 @@ const webhookAnomalyTracker = createWebhookAnomalyTracker({
 });
 function clearZaloWebhookSecurityStateForTest() {
 	webhookRateLimiter.clear();
-	recentWebhookEvents.clearMemory();
 	webhookAnomalyTracker.clear();
 }
 function getZaloWebhookRateLimitStateSizeForTest() {
@@ -26,46 +24,6 @@ function getZaloWebhookRateLimitStateSizeForTest() {
 function getZaloWebhookStatusCounterSizeForTest() {
 	return webhookAnomalyTracker.size();
 }
-function buildReplayEventCacheKey(target, update) {
-	const messageId = update.message?.message_id;
-	if (!messageId) return null;
-	const chatId = update.message?.chat?.id ?? "";
-	const senderId = update.message?.from?.id ?? "";
-	return JSON.stringify([
-		target.path,
-		target.account.accountId,
-		update.event_name,
-		chatId,
-		senderId,
-		messageId
-	]);
-}
-const recentWebhookEvents = createChannelReplayGuard({
-	dedupe: {
-		ttlMs: ZALO_WEBHOOK_REPLAY_WINDOW_MS,
-		memoryMaxSize: 5e3
-	},
-	buildReplayKey: ({ target, update }) => buildReplayEventCacheKey(target, update)
-});
-var ZaloRetryableWebhookError = class extends Error {
-	constructor(message, options) {
-		super(message, options);
-		this.name = "ZaloRetryableWebhookError";
-	}
-};
-async function processZaloReplayGuardedUpdate(params) {
-	const event = {
-		target: params.target,
-		update: params.update
-	};
-	return (await recentWebhookEvents.processGuarded(event, async () => {
-		params.target.statusSink?.({ lastInboundAt: Date.now() });
-		await params.processUpdate(event);
-	}, {
-		dedupe: { now: params.nowMs },
-		onError: (error) => error instanceof ZaloRetryableWebhookError ? "release" : "commit"
-	})).kind === "processed" ? "processed" : "duplicate";
-}
 function recordWebhookStatus(runtime, path, statusCode) {
 	webhookAnomalyTracker.record({
 		key: `${path}:${statusCode}`,
@@ -86,7 +44,7 @@ function registerZaloWebhookTarget(target, opts) {
 	}).unregister;
 	return registerWebhookTarget(webhookTargets, target, opts).unregister;
 }
-async function handleZaloWebhookRequest(req, res, processUpdate) {
+async function handleZaloWebhookRequest(req, res) {
 	return await withResolvedWebhookRequestPipeline({
 		req,
 		res,
@@ -102,13 +60,12 @@ async function handleZaloWebhookRequest(req, res, processUpdate) {
 				trustedProxies,
 				allowRealIpFallback
 			}) ?? req.socket.remoteAddress ?? "unknown"}`;
-			const nowMs = Date.now();
 			if (!applyBasicWebhookRequestGuards({
 				req,
 				res,
 				rateLimiter: webhookRateLimiter,
 				rateLimitKey,
-				nowMs
+				nowMs: Date.now()
 			})) {
 				recordWebhookStatus(targets[0]?.runtime, path, res.statusCode);
 				return true;
@@ -131,40 +88,38 @@ async function handleZaloWebhookRequest(req, res, processUpdate) {
 				recordWebhookStatus(target.runtime, path, res.statusCode);
 				return true;
 			}
-			const body = await readJsonWebhookBodyOrReject({
+			const body = await readWebhookBodyOrReject({
 				req,
 				res,
 				maxBytes: 1024 * 1024,
 				timeoutMs: 3e4,
-				emptyObjectOnEmpty: false,
-				invalidJsonMessage: "Bad Request"
+				invalidBodyMessage: "Bad Request"
 			});
 			if (!body.ok) {
 				recordWebhookStatus(target.runtime, path, res.statusCode);
 				return true;
 			}
-			const raw = body.value;
-			const record = raw && typeof raw === "object" ? raw : null;
-			const update = record && record.ok === true && record.result ? record.result : record ?? void 0;
-			if (!update?.event_name) {
-				res.statusCode = 400;
-				res.end("Bad Request");
+			try {
+				await target.acceptWebhook(body.value);
+			} catch (error) {
+				res.statusCode = error instanceof ZaloWebhookPayloadError ? 400 : 500;
+				res.end(res.statusCode === 400 ? "Bad Request" : "Internal Server Error");
 				recordWebhookStatus(target.runtime, path, res.statusCode);
+				target.runtime.error?.(`[${target.account.accountId}] Zalo webhook admission failed: ${String(error)}`);
 				return true;
 			}
-			runDetachedWebhookWork(() => processZaloReplayGuardedUpdate({
-				target,
-				update,
-				processUpdate,
-				nowMs
-			})).catch((err) => {
-				target.runtime.error?.(`[${target.account.accountId}] Zalo webhook failed: ${String(err)}`);
-			});
 			res.statusCode = 200;
 			res.end("ok");
 			return true;
 		}
 	});
 }
+const zaloWebhookRuntime = {
+	clearZaloWebhookSecurityStateForTest,
+	getZaloWebhookRateLimitStateSizeForTest,
+	getZaloWebhookStatusCounterSizeForTest,
+	handleZaloWebhookRequest,
+	registerZaloWebhookTarget
+};
 //#endregion
-export { ZaloRetryableWebhookError, clearZaloWebhookSecurityStateForTest, getZaloWebhookRateLimitStateSizeForTest, getZaloWebhookStatusCounterSizeForTest, handleZaloWebhookRequest, registerZaloWebhookTarget };
+export { zaloWebhookRuntime };

package/dist/{send-9sVVxyap.js → send-WPSy5EgF.js}

@@ -1,4 +1,4 @@
-import { d as resolveZaloToken, u as resolveZaloAccount } from "./setup-core-fwCh0QUi.js";
+import { d as resolveZaloAccount, f as resolveZaloToken } from "./setup-core-BBA-V-j0.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -6,6 +6,11 @@ import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
 import { readProviderJsonResponse } from "openclaw/plugin-sdk/provider-http";
 import { resolvePinnedHostnameWithPolicy } from "openclaw/plugin-sdk/ssrf-runtime";
 import { makeProxyFetch } from "openclaw/plugin-sdk/fetch-runtime";
+//#region extensions/zalo/src/timeouts.ts
+const ZALO_DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+const ZALO_OUTBOUND_MEDIA_TTL_MS = 2 * 6e4;
+const ZALO_SEND_PHOTO_REQUEST_TIMEOUT_MS = 15e4;
+//#endregion
 //#region extensions/zalo/src/api.ts
 /**
 * Zalo Bot API client
@@ -45,8 +50,8 @@ function resolveZaloApiUrl(apiUrl) {
 async function callZaloApi(method, token, body, options) {
 	const url = `${resolveZaloApiUrl(options?.apiUrl)}/bot${token}/${method}`;
 	const controller = new AbortController();
-	const requestTimeoutMs = options?.timeoutMs === void 0 ? void 0 : resolveTimerTimeoutMs(options.timeoutMs, 1);
-	const timeoutId = requestTimeoutMs === void 0 ? void 0 : setTimeout(() => controller.abort(), requestTimeoutMs);
+	const requestTimeoutMs = resolveTimerTimeoutMs(options?.timeoutMs, ZALO_DEFAULT_REQUEST_TIMEOUT_MS);
+	const timeoutId = setTimeout(() => controller.abort(), requestTimeoutMs);
 	const fetcher = options?.fetch ?? fetch;
 	try {
 		const data = await readProviderJsonResponse(await fetcher(url, {
@@ -58,7 +63,7 @@ async function callZaloApi(method, token, body, options) {
 		if (!data.ok) throw new ZaloApiError(data.description ?? `Zalo API error: ${method}`, data.error_code, data.description);
 		return data;
 	} finally {
-		if (timeoutId) clearTimeout(timeoutId);
+		clearTimeout(timeoutId);
 	}
 }
 /**
@@ -92,7 +97,10 @@ async function sendPhoto(token, params, fetcher) {
 	return callZaloApi("sendPhoto", token, {
 		...params,
 		photo: parsedPhotoUrl.href
-	}, { fetch: fetcher });
+	}, {
+		timeoutMs: ZALO_SEND_PHOTO_REQUEST_TIMEOUT_MS,
+		fetch: fetcher
+	});
 }
 /**
 * Send a temporary chat action such as typing.
@@ -285,4 +293,4 @@ async function sendPhotoZalo(chatId, photoUrl, options = {}) {
 	}, context.fetcher))());
 }
 //#endregion
-export { getMe as a, sendChatAction as c, setWebhook as d, deleteWebhook as i, sendMessage as l, resolveZaloProxyFetch as n, getUpdates as o, ZaloApiError as r, getWebhookInfo as s, sendMessageZalo as t, sendPhoto as u };
+export { getMe as a, sendChatAction as c, setWebhook as d, ZALO_OUTBOUND_MEDIA_TTL_MS as f, deleteWebhook as i, sendMessage as l, resolveZaloProxyFetch as n, getUpdates as o, ZaloApiError as r, getWebhookInfo as s, sendMessageZalo as t, sendPhoto as u };

package/dist/setup-api.js

@@ -1,4 +1,4 @@
-import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-fwCh0QUi.js";
+import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-BBA-V-j0.js";
 import { n as resolveZaloRuntimeGroupPolicy } from "./group-access-8qHRzDHx.js";
 import { loadBundledEntryExportSync } from "openclaw/plugin-sdk/channel-entry-contract";
 //#region extensions/zalo/setup-api.ts

package/dist/{setup-core-fwCh0QUi.js → setup-core-BBA-V-j0.js}

@@ -4,6 +4,7 @@ import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runti
 import { tryReadSecretFileSync } from "openclaw/plugin-sdk/core";
 import { resolveAccountEntry } from "openclaw/plugin-sdk/routing";
 import { buildSecretInputSchema, normalizeResolvedSecretInputString, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
+import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, addWildcardAllowFrom, createDelegatedSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, formatDocsLink, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
@@ -184,16 +185,47 @@ async function promptZaloAllowFrom(params) {
 //#region extensions/zalo/src/setup-core.ts
 const t = createSetupTranslator();
 const channel = "zalo";
-const zaloSetupAdapter = createPatchedAccountSetupAdapter({
-	channelKey: channel,
-	validateInput: createSetupInputPresenceValidator({
-		defaultAccountOnlyEnvError: "ZALO_BOT_TOKEN can only be used for the default account.",
-		whenNotUseEnv: [{
-			someOf: ["token", "tokenFile"],
-			message: "Zalo requires token or --token-file (or --use-env)."
-		}]
+const zaloSetupAdapter = {
+	...createPatchedAccountSetupAdapter({
+		channelKey: channel,
+		validateInput: createSetupInputPresenceValidator({
+			defaultAccountOnlyEnvError: "ZALO_BOT_TOKEN can only be used for the default account.",
+			whenNotUseEnv: [{
+				someOf: ["token", "tokenFile"],
+				message: "Zalo requires token or --token-file (or --use-env)."
+			}]
+		}),
+		buildPatch: (input) => input.useEnv ? {} : input.tokenFile ? { tokenFile: input.tokenFile } : input.token ? { botToken: input.token } : {}
 	}),
-	buildPatch: (input) => input.useEnv ? {} : input.tokenFile ? { tokenFile: input.tokenFile } : input.token ? { botToken: input.token } : {}
+	singleAccountKeysToMove: ["webhookSecret", "tokenFile"]
+};
+const zaloSetupContract = defineChannelSetupContract({
+	fields: {
+		token: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token <token>",
+				description: "Zalo bot token"
+			}
+		},
+		tokenFile: {
+			kind: "string",
+			sensitive: true,
+			cli: {
+				flags: "--token-file <path>",
+				description: "Zalo bot token file"
+			}
+		},
+		useEnv: {
+			kind: "boolean",
+			cli: {
+				flags: "--use-env",
+				description: "Use ZALO_BOT_TOKEN"
+			}
+		}
+	},
+	legacyAdapter: zaloSetupAdapter
 });
 const zaloDmPolicy = {
 	label: "Zalo",
@@ -284,4 +316,4 @@ function createZaloSetupWizardProxy(loadWizard) {
 	});
 }
 //#endregion
-export { promptZaloAllowFrom as a, listZaloAccountIds as c, resolveZaloToken as d, buildSecretInputSchema as f, noteZaloTokenHelp as i, resolveDefaultZaloAccountId as l, zaloDmPolicy as n, accounts_exports as o, normalizeSecretInputString as p, zaloSetupAdapter as r, listEnabledZaloAccounts as s, createZaloSetupWizardProxy as t, resolveZaloAccount as u };
+export { noteZaloTokenHelp as a, listEnabledZaloAccounts as c, resolveZaloAccount as d, resolveZaloToken as f, zaloSetupContract as i, listZaloAccountIds as l, normalizeSecretInputString as m, zaloDmPolicy as n, promptZaloAllowFrom as o, buildSecretInputSchema as p, zaloSetupAdapter as r, accounts_exports as s, createZaloSetupWizardProxy as t, resolveDefaultZaloAccountId as u };

package/dist/{setup-surface-8eRimod9.js → setup-surface-dFkadq_c.js}

@@ -1,4 +1,4 @@
-import { a as promptZaloAllowFrom, i as noteZaloTokenHelp, n as zaloDmPolicy, u as resolveZaloAccount } from "./setup-core-fwCh0QUi.js";
+import { a as noteZaloTokenHelp, d as resolveZaloAccount, n as zaloDmPolicy, o as promptZaloAllowFrom } from "./setup-core-BBA-V-j0.js";
 import { DEFAULT_ACCOUNT_ID, buildSingleChannelSecretPromptState, createSetupTranslator, createStandardChannelSetupStatus, hasConfiguredSecretInput, promptSingleChannelSecretInput, runSingleChannelSecretStep } from "openclaw/plugin-sdk/setup";
 //#region extensions/zalo/src/setup-surface.ts
 const t = createSetupTranslator();

package/dist/webhook-spool-Ozf0tcbs.js

@@ -0,0 +1,174 @@
+import { t as getZaloRuntime } from "./runtime-api-B53PGWBW.js";
+import { r as ZaloApiError } from "./send-WPSy5EgF.js";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor } from "openclaw/plugin-sdk/channel-outbound";
+import { runDetachedWebhookWork } from "openclaw/plugin-sdk/webhook-request-guards";
+//#region extensions/zalo/src/webhook-spool.ts
+const ZALO_WEBHOOK_SPOOL_VERSION = 1;
+const ZALO_WEBHOOK_DRAIN_INTERVAL_MS = 500;
+const ZALO_WEBHOOK_MAX_CONCURRENT_DELIVERIES = 8;
+const ZALO_WEBHOOK_PRUNE_INTERVAL_MS = 3600 * 1e3;
+const ZALO_WEBHOOK_COMPLETED_TTL_MS = 720 * 60 * 6e4;
+const ZALO_WEBHOOK_COMPLETED_MAX_ENTRIES = 2e4;
+const ZALO_WEBHOOK_FAILED_TTL_MS = 720 * 60 * 6e4;
+const ZALO_WEBHOOK_FAILED_MAX_ENTRIES = 5e3;
+var ZaloWebhookPayloadError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ZaloWebhookPayloadError";
+	}
+};
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.trim() ? value.trim() : null;
+}
+function parseRawRecord(rawEvent) {
+	let parsed;
+	try {
+		parsed = JSON.parse(rawEvent);
+	} catch (error) {
+		throw new ZaloWebhookPayloadError("Zalo webhook body contains invalid JSON.", { cause: error });
+	}
+	if (!isRecord(parsed)) throw new ZaloWebhookPayloadError("Zalo webhook body must be a JSON object.");
+	return parsed;
+}
+function resolveUpdateRecord(envelope) {
+	if (envelope.ok === true && isRecord(envelope.result)) return envelope.result;
+	return envelope;
+}
+function inspectZaloWebhookEvent(rawEvent) {
+	const update = resolveUpdateRecord(parseRawRecord(rawEvent));
+	const message = isRecord(update.message) ? update.message : null;
+	const eventId = nonEmptyString(message?.message_id);
+	if (!eventId) throw new ZaloWebhookPayloadError("Zalo webhook message is missing message.message_id.");
+	const chatId = nonEmptyString((isRecord(message?.chat) ? message.chat : null)?.id);
+	if (!chatId) throw new ZaloWebhookPayloadError("Zalo webhook message is missing message.chat.id.");
+	return {
+		eventId,
+		laneKey: `chat:${chatId}`,
+		update
+	};
+}
+function parseClaimedUpdate(payload, claimedId) {
+	if (payload.version !== ZALO_WEBHOOK_SPOOL_VERSION || typeof payload.rawEvent !== "string") throw new ZaloWebhookPayloadError("Zalo webhook spool payload is invalid.");
+	const facts = inspectZaloWebhookEvent(payload.rawEvent);
+	if (facts.eventId !== claimedId) throw new ZaloWebhookPayloadError("Zalo webhook message id changed after durable admission.");
+	const eventName = nonEmptyString(facts.update.event_name);
+	if (eventName !== "message.text.received" && eventName !== "message.image.received" && eventName !== "message.sticker.received" && eventName !== "message.unsupported.received") throw new ZaloWebhookPayloadError("Zalo webhook event_name is unsupported.");
+	const message = facts.update.message;
+	const from = isRecord(message.from) ? message.from : null;
+	const chat = isRecord(message.chat) ? message.chat : null;
+	if (!nonEmptyString(from?.id)) throw new ZaloWebhookPayloadError("Zalo webhook message is missing message.from.id.");
+	if (chat?.chat_type !== "PRIVATE" && chat?.chat_type !== "GROUP") throw new ZaloWebhookPayloadError("Zalo webhook message has an invalid chat type.");
+	if (typeof message.date !== "number" || !Number.isFinite(message.date)) throw new ZaloWebhookPayloadError("Zalo webhook message has an invalid date.");
+	if (eventName === "message.text.received" && typeof message.text !== "string") throw new ZaloWebhookPayloadError("Zalo text event is missing message.text.");
+	return facts.update;
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function isZaloAuthenticationFailure(error) {
+	let current = error;
+	const seen = /* @__PURE__ */ new Set();
+	while (current && typeof current === "object" && !seen.has(current)) {
+		seen.add(current);
+		const candidate = current;
+		if (current instanceof ZaloApiError && (current.errorCode === 401 || current.errorCode === 403) || candidate.status === 401 || candidate.status === 403 || candidate.statusCode === 401 || candidate.statusCode === 403) return true;
+		current = candidate.cause;
+	}
+	return false;
+}
+function createZaloWebhookIngress(options) {
+	const queue = options.queue ?? getZaloRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
+	const deferredClaims = /* @__PURE__ */ new Map();
+	const monitor = createChannelIngressMonitor({
+		queue,
+		inspect: (rawEvent) => inspectZaloWebhookEvent(rawEvent),
+		payload: {
+			storage: "raw-event",
+			version: ZALO_WEBHOOK_SPOOL_VERSION,
+			serialize: (rawEvent) => rawEvent,
+			deserialize: (rawEvent) => rawEvent,
+			createClaimError: (kind) => new ZaloWebhookPayloadError(kind === "invalid-version" ? "Zalo webhook spool payload is invalid." : "Zalo webhook identity changed after durable admission.")
+		},
+		deliver: async (_rawEvent, lifecycle, claim) => {
+			const update = parseClaimedUpdate(claim.payload, claim.id);
+			const boundLifecycle = bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle;
+			let resolveDeferredClaim;
+			const deferredClaim = new Promise((resolve) => {
+				resolveDeferredClaim = resolve;
+			});
+			let deferredClaimSettled = false;
+			const settleDeferredClaim = () => {
+				if (deferredClaimSettled) return;
+				deferredClaimSettled = true;
+				if (deferredClaims.get(claim.id) === deferredClaim) deferredClaims.delete(claim.id);
+				resolveDeferredClaim();
+			};
+			await options.deliver(update, {
+				...boundLifecycle,
+				onAdopted: async () => {
+					try {
+						await boundLifecycle.onAdopted();
+					} finally {
+						settleDeferredClaim();
+					}
+				},
+				onDeferred: () => {
+					if (!deferredClaimSettled) deferredClaims.set(claim.id, deferredClaim);
+					boundLifecycle.onDeferred();
+				},
+				onAbandoned: () => {
+					Promise.resolve(boundLifecycle.onAbandoned()).finally(settleDeferredClaim);
+				}
+			});
+			return deferredClaims.has(claim.id) ? { kind: "deferred" } : { kind: "completed" };
+		},
+		pollIntervalMs: ZALO_WEBHOOK_DRAIN_INTERVAL_MS,
+		retention: {
+			pruneIntervalMs: ZALO_WEBHOOK_PRUNE_INTERVAL_MS,
+			completedTtlMs: ZALO_WEBHOOK_COMPLETED_TTL_MS,
+			completedMaxEntries: ZALO_WEBHOOK_COMPLETED_MAX_ENTRIES,
+			failedTtlMs: ZALO_WEBHOOK_FAILED_TTL_MS,
+			failedMaxEntries: ZALO_WEBHOOK_FAILED_MAX_ENTRIES
+		},
+		waitForDeliveryIdleBeforeRepump: false,
+		runPumpTask: runDetachedWebhookWork,
+		drain: {
+			adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
+			startLimit: ZALO_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
+			retryPolicy: {
+				maxAttempts: DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS,
+				deadLetterMinAgeMs: 0
+			},
+			resolveNonRetryableFailure: (error) => {
+				if (error instanceof ZaloWebhookPayloadError) return {
+					reason: "invalid-event",
+					message: error.message
+				};
+				if (isZaloAuthenticationFailure(error)) return {
+					reason: "authentication-failed",
+					message: errorText(error)
+				};
+				return null;
+			},
+			onLog: (message) => options.runtime.error?.(`zalo ingress: ${message}`)
+		},
+		createStoppedError: () => /* @__PURE__ */ new Error("Zalo ingress stopped."),
+		onError: (error) => options.runtime.error?.(`zalo ingress drain failed: ${errorText(error)}`)
+	});
+	return {
+		accept: async (rawEvent) => {
+			await monitor.admit(rawEvent);
+		},
+		start: monitor.start,
+		stop: async () => {
+			await monitor.stop();
+			await Promise.allSettled(deferredClaims.values());
+		}
+	};
+}
+const zaloWebhookIngressRuntime = { createZaloWebhookIngress };
+//#endregion
+export { ZaloWebhookPayloadError, zaloWebhookIngressRuntime };

package/npm-shrinkwrap.json

@@ -1,17 +1,17 @@
 {
   "name": "@openclaw/zalo",
-  "version": "2026.7.2-beta.3",
+  "version": "2026.7.2-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@openclaw/zalo",
-      "version": "2026.7.2-beta.3",
+      "version": "2026.7.2-beta.4",
       "dependencies": {
         "zod": "4.4.3"
       },
       "peerDependencies": {
-        "openclaw": ">=2026.7.2-beta.3"
+        "openclaw": ">=2026.7.2-beta.4"
       },
       "peerDependenciesMeta": {
         "openclaw": {

package/openclaw.plugin.json

@@ -9,12 +9,6 @@
   "channels": [
     "zalo"
   ],
-  "channelEnvVars": {
-    "zalo": [
-      "ZALO_BOT_TOKEN",
-      "ZALO_WEBHOOK_SECRET"
-    ]
-  },
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/zalo",
-  "version": "2026.7.2-beta.3",
+  "version": "2026.7.2-beta.4",
   "description": "OpenClaw Zalo channel plugin for bot and webhook chats.",
   "repository": {
     "type": "git",
@@ -8,7 +8,7 @@
   },
   "type": "module",
   "peerDependencies": {
-    "openclaw": ">=2026.7.2-beta.3"
+    "openclaw": ">=2026.7.2-beta.4"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -20,8 +20,19 @@
       "./index.ts"
     ],
     "setupEntry": "./dist/setup-entry.js",
+    "setupFeatures": {
+      "configPromotion": true
+    },
     "channel": {
       "id": "zalo",
+      "configuredState": {
+        "env": {
+          "anyOf": [
+            "ZALO_BOT_TOKEN",
+            "ZALO_WEBHOOK_SECRET"
+          ]
+        }
+      },
       "label": "Zalo",
       "selectionLabel": "Zalo (Bot API)",
       "docsPath": "/channels/zalo",
@@ -31,7 +42,37 @@
         "zl"
       ],
       "order": 80,
-      "quickstartAllowFrom": true
+      "quickstartAllowFrom": true,
+      "setup": {
+        "fields": [
+          {
+            "key": "token",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--token <token>",
+              "description": "Zalo bot token"
+            }
+          },
+          {
+            "key": "tokenFile",
+            "kind": "string",
+            "sensitive": true,
+            "cli": {
+              "flags": "--token-file <path>",
+              "description": "Zalo bot token file"
+            }
+          },
+          {
+            "key": "useEnv",
+            "kind": "boolean",
+            "cli": {
+              "flags": "--use-env",
+              "description": "Use ZALO_BOT_TOKEN"
+            }
+          }
+        ]
+      }
     },
     "install": {
       "npmSpec": "@openclaw/zalo",
@@ -39,10 +80,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.3"
+      "pluginApi": ">=2026.7.2-beta.4"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.3"
+      "openclawVersion": "2026.7.2-beta.4"
     },
     "release": {
       "publishToClawHub": true,