@openclaw/zalo 2026.7.2-beta.7 → 2026.7.34

package/dist/{monitor-C5cximHM.js → .setup/monitor-JTCxbIQP.mjs}

@@ -1,19 +1,19 @@
-import { n as resolveZaloRuntimeGroupPolicy, t as normalizeZaloAllowEntry } from "./group-access-8qHRzDHx.js";
-import { t as getZaloRuntime } from "./runtime-api-qxdOyk3M.js";
-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-BUvbbedq.js";
-import { createLazyRuntimeModule, createLazyRuntimeNamedExport } from "openclaw/plugin-sdk/lazy-runtime";
+import { n as resolveZaloRuntimeGroupPolicy, t as normalizeZaloAllowEntry } from "./group-access-8qHRzDHx.mjs";
+import { t as getZaloRuntime } from "./runtime-api-CAA4ZtqF.mjs";
+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-CNCw5UOt.mjs";
+import { createLazyRuntimeModule } 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";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
+import { resolveInboundRouteEnvelopeBuilderWithRuntime } from "openclaw/plugin-sdk/inbound-envelope";
 import { registerPluginHttpRoute, resolveWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
-import { formatInboundMediaUnavailableText, resolveChannelInboundRouteEnvelope } from "openclaw/plugin-sdk/channel-inbound";
+import { formatInboundMediaUnavailableText } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { sleepWithAbort, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
+import { waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
 import { createHostedOutboundMediaStore } from "openclaw/plugin-sdk/outbound-media";
-import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
 //#region extensions/zalo/src/monitor-durable.ts
 function prepareZaloDurableReplyPayload(params) {
 	if (!params.payload.text) return params.payload;
@@ -30,6 +30,7 @@ function resolveZaloDurableReplyOptions(params) {
 }
 //#endregion
 //#region extensions/zalo/src/outbound-media.ts
+const ZALO_OUTBOUND_MEDIA_TTL_MS = 12e4;
 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}$/;
@@ -73,7 +74,7 @@ function resolveHostedZaloMediaRoutePath(params) {
 }
 async function prepareHostedZaloMediaUrl(params) {
 	const now = asDateTimestampMs(Date.now());
-	if ((now === void 0 ? void 0 : resolveExpiresAtMsFromDurationMs(12e4, { nowMs: now })) === void 0) throw new Error("Zalo outbound media expiry could not be resolved");
+	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");
 	const routePath = resolveHostedZaloMediaRoutePath({
 		webhookUrl: params.webhookUrl,
 		webhookPath: params.webhookPath
@@ -128,7 +129,7 @@ async function tryHandleHostedZaloMediaRequest(req, res) {
 		res.end("Expired");
 		return true;
 	}
-	if (!safeEqualSecret(url.searchParams.get("token"), entry.metadata.token)) {
+	if (url.searchParams.get("token") !== entry.metadata.token) {
 		res.statusCode = 401;
 		res.end("Unauthorized");
 		return true;
@@ -163,12 +164,7 @@ function resolveZaloTimestampMs(date) {
 	if (!date) return;
 	return date >= UNIX_MILLISECONDS_THRESHOLD ? date : date * 1e3;
 }
-const loadZaloWebhookRuntime = createLazyRuntimeNamedExport(() => import("./monitor.webhook-D56OCa3C.js"), "zaloWebhookRuntime");
-const loadZaloWebhookIngressRuntime = createLazyRuntimeNamedExport(() => import("./webhook-spool-DzCPbb3O.js"), "zaloWebhookIngressRuntime");
-const loadZaloWebhookModule = createLazyRuntimeModule(async () => ({
-	...await loadZaloWebhookRuntime(),
-	...await loadZaloWebhookIngressRuntime()
-}));
+const loadZaloWebhookModule = createLazyRuntimeModule(() => import("./monitor.webhook-BwPNGSB4.mjs"));
 function releaseSharedHostedMediaRouteRef(routePath) {
 	const current = hostedMediaRouteRefs.get(routePath);
 	if (!current) return;
@@ -229,7 +225,22 @@ function logVerbose(core, runtime, message) {
 }
 async function handleZaloWebhookRequest(req, res) {
 	const { handleZaloWebhookRequest: handleZaloWebhookRequestInternal } = await loadZaloWebhookModule();
-	return await handleZaloWebhookRequestInternal(req, res);
+	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
+		});
+	});
 }
 function startPollingLoop(params) {
 	const { token, account, config, runtime, core, mediaMaxMb, canHostMedia, webhookUrl, webhookPath, abortSignal, isStopped, statusSink, fetcher } = params;
@@ -263,7 +274,9 @@ function startPollingLoop(params) {
 		} catch (err) {
 			if (err instanceof ZaloApiError && err.isPollingTimeout) {} else if (!isStopped() && !abortSignal.aborted) {
 				runtime.error?.(`[${account.accountId}] Zalo polling error: ${formatZaloError(err)}`);
-				await sleepWithAbort(5e3, abortSignal).catch(() => void 0);
+				await new Promise((resolve) => {
+					setTimeout(resolve, 5e3);
+				});
 			}
 		}
 		if (!isStopped() && !abortSignal.aborted) setImmediate(() => {
@@ -286,8 +299,7 @@ async function processUpdate(params) {
 		webhookUrl: params.webhookUrl,
 		webhookPath: params.webhookPath,
 		statusSink,
-		fetcher,
-		turnAdoptionLifecycle: params.turnAdoptionLifecycle
+		fetcher
 	};
 	if (!message) return;
 	switch (event_name) {
@@ -307,9 +319,7 @@ async function processUpdate(params) {
 		case "message.sticker.received":
 			logVerbose(core, runtime, `[${account.accountId}] Received sticker from ${message.from.id}`);
 			break;
-		case "message.unsupported.received":
-			logVerbose(core, runtime, `[${account.accountId}] Received unsupported message type from ${message.from.id}`);
-			break;
+		case "message.unsupported.received": logVerbose(core, runtime, `[${account.accountId}] Received unsupported message type from ${message.from.id}`);
 	}
 }
 async function handleTextMessage(params) {
@@ -319,7 +329,6 @@ async function handleTextMessage(params) {
 	await processMessageWithPipeline({
 		...params,
 		text,
-		mediaKind: void 0,
 		mediaPath: void 0,
 		mediaType: void 0
 	});
@@ -330,8 +339,7 @@ async function handleImageMessage(params) {
 	const authorization = await authorizeZaloMessage({
 		...params,
 		text: caption,
-		mediaKind: "image",
-		mediaPath: void 0,
+		mediaPath: "__pending_media__",
 		mediaType: void 0
 	});
 	if (!authorization) return;
@@ -342,7 +350,7 @@ async function handleImageMessage(params) {
 		const saved = await core.channel.media.saveRemoteMedia({
 			url: photo_url,
 			maxBytes,
-			responseHeaderTimeoutMs: ZALO_MEDIA_RESPONSE_HEADER_TIMEOUT_MS,
+			timeoutMs: ZALO_MEDIA_RESPONSE_HEADER_TIMEOUT_MS,
 			readIdleTimeoutMs: ZALO_MEDIA_READ_IDLE_TIMEOUT_MS
 		});
 		mediaPath = saved.path;
@@ -351,21 +359,21 @@ async function handleImageMessage(params) {
 		runtime.error?.(`[${account.accountId}] Failed to download Zalo image: ${String(err)}`);
 	}
 	const agentBody = mediaPath ? authorization.rawBody : formatInboundMediaUnavailableText({
-		body: authorization.rawBody,
+		body: caption,
+		mediaPlaceholder: "<media:image>",
 		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, token, statusSink, fetcher } = params;
+	const { message, account, config, runtime, core, text, mediaPath, token, statusSink, fetcher } = params;
 	const pairing = createChannelPairingController({
 		core,
 		channel: "zalo",
@@ -378,7 +386,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() ?? "";
+	const rawBody = text?.trim() || (mediaPath ? "<media:image>" : "");
 	const { groupPolicy, providerMissingFallbackApplied } = resolveZaloRuntimeGroupPolicy({
 		providerConfigPresent: config.channels?.zalo !== void 0,
 		groupPolicy: account.config.groupPolicy,
@@ -460,7 +468,7 @@ async function authorizeZaloMessage(params) {
 	};
 }
 async function processMessageWithPipeline(params) {
-	const { message, token, account, config, runtime, core, mediaPath, mediaKind, mediaType, statusSink, fetcher, agentBody: agentBodyOverride, authorization: authorizationOverride } = params;
+	const { message, token, account, config, runtime, core, mediaPath, mediaType, statusSink, fetcher, agentBody: agentBodyOverride, authorization: authorizationOverride } = params;
 	const { message_id, date } = message;
 	const authorization = authorizationOverride ?? await authorizeZaloMessage({
 		...params,
@@ -470,14 +478,16 @@ async function processMessageWithPipeline(params) {
 	if (!authorization) return;
 	const { isGroup, chatId, senderId, senderName, rawBody, commandAuthorized } = authorization;
 	const agentBody = agentBodyOverride ?? rawBody;
-	const { route, buildEnvelope } = resolveChannelInboundRouteEnvelope({
+	const { route, buildEnvelope } = resolveInboundRouteEnvelopeBuilderWithRuntime({
 		cfg: config,
 		channel: "zalo",
 		accountId: account.accountId,
 		peer: {
 			kind: isGroup ? "group" : "direct",
 			id: chatId
-		}
+		},
+		runtime: core.channel,
+		sessionStore: config.session?.store
 	});
 	if (isGroup && core.channel.commands.isControlCommandMessage(rawBody, config) && commandAuthorized !== true) {
 		logVerbose(core, runtime, `zalo: drop control command from unauthorized sender ${senderId}`);
@@ -485,7 +495,7 @@ async function processMessageWithPipeline(params) {
 	}
 	const fromLabel = isGroup ? `group:${chatId}` : senderName || `user:${senderId}`;
 	const timestamp = resolveZaloTimestampMs(date);
-	const body = buildEnvelope({
+	const { storePath, body } = buildEnvelope({
 		channel: "Zalo",
 		from: fromLabel,
 		timestamp,
@@ -508,7 +518,6 @@ async function processMessageWithPipeline(params) {
 		},
 		route: {
 			agentId: route.agentId,
-			dmScope: route.dmScope,
 			accountId: route.accountId,
 			routeSessionKey: route.sessionKey
 		},
@@ -519,11 +528,10 @@ async function processMessageWithPipeline(params) {
 			rawBody,
 			commandBody: rawBody
 		},
-		media: mediaKind || mediaPath || mediaType ? [{
+		media: mediaPath || mediaType ? [{
 			path: mediaPath,
 			url: mediaPath,
-			contentType: mediaType,
-			kind: mediaKind ?? void 0
+			contentType: mediaType
 		}] : void 0,
 		extra: {
 			CommandAuthorized: commandAuthorized,
@@ -535,16 +543,16 @@ async function processMessageWithPipeline(params) {
 		channel: "zalo",
 		accountId: account.accountId
 	});
-	await core.channel.inbound.dispatch({
+	await core.channel.inbound.dispatchReply({
 		cfg: config,
 		channel: "zalo",
 		accountId: account.accountId,
-		route: {
-			agentId: route.agentId,
-			dmScope: route.dmScope,
-			sessionKey: route.sessionKey
-		},
+		agentId: route.agentId,
+		routeSessionKey: route.sessionKey,
+		storePath,
 		ctxPayload,
+		recordInboundSession: core.channel.session.recordInboundSession,
+		dispatchReplyWithBufferedBlockDispatcher: core.channel.reply.dispatchReplyWithBufferedBlockDispatcher,
 		delivery: {
 			preparePayload: (payload) => prepareZaloDurableReplyPayload({
 				payload,
@@ -601,8 +609,7 @@ 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) {
@@ -664,7 +671,6 @@ async function monitorZaloProvider(options) {
 	}) : void 0;
 	let stopped = false;
 	const stopHandlers = [];
-	const asyncStopHandlers = [];
 	let cleanupWebhook;
 	const stop = () => {
 		if (stopped) return;
@@ -674,10 +680,6 @@ async function monitorZaloProvider(options) {
 	const stopOnAbort = () => {
 		if (!useWebhook) stop();
 	};
-	if (abortSignal.aborted) {
-		stopOnAbort();
-		return;
-	}
 	abortSignal.addEventListener("abort", stopOnAbort, { once: true });
 	runtime.log?.(`[${account.accountId}] Zalo provider init mode=${mode} mediaMaxMb=${String(effectiveMediaMaxMb)}`);
 	try {
@@ -690,44 +692,46 @@ async function monitorZaloProvider(options) {
 			stopHandlers.push(unregisterHostedMediaRoute);
 		}
 		if (useWebhook) {
-			const { createZaloWebhookIngress, registerZaloWebhookTarget } = await loadZaloWebhookModule();
+			const { 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)}`);
-			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);
+			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 unregister = registerZaloWebhookTarget({
+				token,
 				account,
 				config,
 				runtime,
+				core,
 				path,
+				webhookUrl: effectiveWebhookUrl,
+				webhookPath: path,
 				secret: webhookSecret,
-				acceptWebhook: ingress.accept
+				statusSink: (patch) => statusSink?.(patch),
+				mediaMaxMb: effectiveMediaMaxMb,
+				canHostMedia,
+				fetcher
 			}, { route: {
 				auth: "plugin",
 				match: "exact",
@@ -744,25 +748,6 @@ 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;
 		}
@@ -806,7 +791,6 @@ 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-D56OCa3C.js → .setup/monitor.webhook-BwPNGSB4.mjs}

@@ -1,16 +1,18 @@
-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-qxdOyk3M.js";
-import { ZaloWebhookPayloadError } from "./webhook-spool-DzCPbb3O.js";
+import { B as registerWebhookTargetWithPluginRoute, I as readJsonWebhookBodyOrReject, K as resolveWebhookTargetWithAuthOrRejectSync, Q as withResolvedWebhookRequestPipeline, V as resolveClientIp, 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-CAA4ZtqF.mjs";
+import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
-import { readWebhookBodyOrReject } from "openclaw/plugin-sdk/webhook-request-guards";
 //#region extensions/zalo/src/monitor.webhook.ts
-const ZALO_WEBHOOK_ACCEPTED_HEADER = "x-openclaw-delivery-accepted";
-const ZALO_WEBHOOK_ACCEPTED_VALUE = "durable";
+const ZALO_WEBHOOK_REPLAY_WINDOW_MS = 3e5;
 const webhookTargets = /* @__PURE__ */ new Map();
 const webhookRateLimiter = createFixedWindowRateLimiter({
 	windowMs: WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs,
 	maxRequests: WEBHOOK_RATE_LIMIT_DEFAULTS.maxRequests,
 	maxTrackedKeys: WEBHOOK_RATE_LIMIT_DEFAULTS.maxTrackedKeys
 });
+const recentWebhookEvents = createClaimableDedupe({
+	ttlMs: ZALO_WEBHOOK_REPLAY_WINDOW_MS,
+	memoryMaxSize: 5e3
+});
 const webhookAnomalyTracker = createWebhookAnomalyTracker({
 	maxTrackedKeys: WEBHOOK_ANOMALY_COUNTER_DEFAULTS.maxTrackedKeys,
 	ttlMs: WEBHOOK_ANOMALY_COUNTER_DEFAULTS.ttlMs,
@@ -18,6 +20,7 @@ const webhookAnomalyTracker = createWebhookAnomalyTracker({
 });
 function clearZaloWebhookSecurityStateForTest() {
 	webhookRateLimiter.clear();
+	recentWebhookEvents.clearMemory();
 	webhookAnomalyTracker.clear();
 }
 function getZaloWebhookRateLimitStateSizeForTest() {
@@ -26,6 +29,47 @@ 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
+	]);
+}
+var ZaloRetryableWebhookError = class extends Error {
+	constructor(message, options) {
+		super(message, options);
+		this.name = "ZaloRetryableWebhookError";
+	}
+};
+async function processZaloReplayGuardedUpdate(params) {
+	const replayEventKey = buildReplayEventCacheKey(params.target, params.update);
+	if (replayEventKey) {
+		if ((await recentWebhookEvents.claim(replayEventKey, { now: params.nowMs })).kind !== "claimed") return "duplicate";
+	}
+	params.target.statusSink?.({ lastInboundAt: Date.now() });
+	try {
+		await params.processUpdate({
+			update: params.update,
+			target: params.target
+		});
+		if (replayEventKey) await recentWebhookEvents.commit(replayEventKey);
+		return "processed";
+	} catch (error) {
+		if (replayEventKey) {
+			if (error instanceof ZaloRetryableWebhookError) recentWebhookEvents.release(replayEventKey, { error });
+			else await recentWebhookEvents.commit(replayEventKey);
+		}
+		throw error;
+	}
+}
 function recordWebhookStatus(runtime, path, statusCode) {
 	webhookAnomalyTracker.record({
 		key: `${path}:${statusCode}`,
@@ -46,7 +90,7 @@ function registerZaloWebhookTarget(target, opts) {
 	}).unregister;
 	return registerWebhookTarget(webhookTargets, target, opts).unregister;
 }
-async function handleZaloWebhookRequest(req, res) {
+async function handleZaloWebhookRequest(req, res, processUpdate) {
 	return await withResolvedWebhookRequestPipeline({
 		req,
 		res,
@@ -62,12 +106,13 @@ async function handleZaloWebhookRequest(req, res) {
 				trustedProxies,
 				allowRealIpFallback
 			}) ?? req.socket.remoteAddress ?? "unknown"}`;
+			const nowMs = Date.now();
 			if (!applyBasicWebhookRequestGuards({
 				req,
 				res,
 				rateLimiter: webhookRateLimiter,
 				rateLimitKey,
-				nowMs: Date.now()
+				nowMs
 			})) {
 				recordWebhookStatus(targets[0]?.runtime, path, res.statusCode);
 				return true;
@@ -90,39 +135,40 @@ async function handleZaloWebhookRequest(req, res) {
 				recordWebhookStatus(target.runtime, path, res.statusCode);
 				return true;
 			}
-			const body = await readWebhookBodyOrReject({
+			const body = await readJsonWebhookBodyOrReject({
 				req,
 				res,
-				maxBytes: 1024 * 1024,
+				maxBytes: 1048576,
 				timeoutMs: 3e4,
-				invalidBodyMessage: "Bad Request"
+				emptyObjectOnEmpty: false,
+				invalidJsonMessage: "Bad Request"
 			});
 			if (!body.ok) {
 				recordWebhookStatus(target.runtime, path, res.statusCode);
 				return true;
 			}
-			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");
+			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");
 				recordWebhookStatus(target.runtime, path, res.statusCode);
-				target.runtime.error?.(`[${target.account.accountId}] Zalo webhook admission failed: ${String(error)}`);
 				return true;
 			}
-			res.setHeader(ZALO_WEBHOOK_ACCEPTED_HEADER, ZALO_WEBHOOK_ACCEPTED_VALUE);
+			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 { zaloWebhookRuntime };
+export { ZaloRetryableWebhookError, clearZaloWebhookSecurityStateForTest, getZaloWebhookRateLimitStateSizeForTest, getZaloWebhookStatusCounterSizeForTest, handleZaloWebhookRequest, registerZaloWebhookTarget };

package/dist/{runtime-api-qxdOyk3M.js → .setup/runtime-api-CAA4ZtqF.mjs}

@@ -6,10 +6,11 @@ import { buildBaseAccountStatusSnapshot } from "openclaw/plugin-sdk/status-helpe
 import { chunkTextForOutbound as chunkTextForOutbound$1 } from "openclaw/plugin-sdk/text-chunking";
 import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, buildChannelConfigSchema, createDedupeCache, formatPairingApproveHint, jsonResult, normalizeAccountId as normalizeAccountId$1, readStringParam, resolveClientIp } from "openclaw/plugin-sdk/core";
 import { buildSecretInputSchema, hasConfiguredSecretInput as hasConfiguredSecretInput$1, normalizeResolvedSecretInputString, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
-import { addWildcardAllowFrom, applyAccountNameToChannelSection, applySetupAccountConfigPatch, buildSingleChannelSecretPromptState as buildSingleChannelSecretPromptState$1, mergeAllowFromEntries as mergeAllowFromEntries$1, migrateBaseNameToDefaultAccount, promptSingleChannelSecretInput as promptSingleChannelSecretInput$1, runSingleChannelSecretStep as runSingleChannelSecretStep$1, setTopLevelChannelDmPolicyWithAllowFrom } from "openclaw/plugin-sdk/setup";
+import { addWildcardAllowFrom as addWildcardAllowFrom$1, applyAccountNameToChannelSection, applySetupAccountConfigPatch, buildSingleChannelSecretPromptState as buildSingleChannelSecretPromptState$1, mergeAllowFromEntries as mergeAllowFromEntries$1, migrateBaseNameToDefaultAccount, promptSingleChannelSecretInput as promptSingleChannelSecretInput$1, runSingleChannelSecretStep as runSingleChannelSecretStep$1, setTopLevelChannelDmPolicyWithAllowFrom } from "openclaw/plugin-sdk/setup";
 import { resolveDefaultGroupPolicy as resolveDefaultGroupPolicy$1, resolveOpenProviderRuntimeGroupPolicy as resolveOpenProviderRuntimeGroupPolicy$1, warnMissingProviderGroupPolicyFallbackOnce as warnMissingProviderGroupPolicyFallbackOnce$1 } from "openclaw/plugin-sdk/runtime-group-policy";
 import { createChannelPairingController as createChannelPairingController$1 } from "openclaw/plugin-sdk/channel-pairing";
 import { logTypingFailure as logTypingFailure$1 } from "openclaw/plugin-sdk/channel-feedback";
+import { resolveInboundRouteEnvelopeBuilderWithRuntime as resolveInboundRouteEnvelopeBuilderWithRuntime$1 } from "openclaw/plugin-sdk/inbound-envelope";
 import { waitForAbortSignal } from "openclaw/plugin-sdk/runtime";
 import { WEBHOOK_ANOMALY_COUNTER_DEFAULTS, WEBHOOK_RATE_LIMIT_DEFAULTS, applyBasicWebhookRequestGuards, createFixedWindowRateLimiter, createWebhookAnomalyTracker, readJsonWebhookBodyOrReject, registerPluginHttpRoute as registerPluginHttpRoute$1, registerWebhookTarget, registerWebhookTargetWithPluginRoute, resolveWebhookPath as resolveWebhookPath$1, resolveWebhookTargetWithAuthOrRejectSync, withResolvedWebhookRequestPipeline } from "openclaw/plugin-sdk/webhook-ingress";
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
@@ -19,4 +20,4 @@ const { setRuntime: setZaloRuntime, getRuntime: getZaloRuntime } = createPluginR
 	errorMessage: "Zalo runtime not initialized"
 });
 //#endregion
-export { mergeAllowFromEntries$1 as A, registerWebhookTargetWithPluginRoute as B, formatAllowFromLowercase$1 as C, isNumericTargetId as D, isNormalizedSenderAllowed as E, promptSingleChannelSecretInput$1 as F, resolveWebhookTargetWithAuthOrRejectSync as G, resolveDefaultGroupPolicy$1 as H, readJsonWebhookBodyOrReject as I, setTopLevelChannelDmPolicyWithAllowFrom as J, runSingleChannelSecretStep$1 as K, readStringParam as L, normalizeAccountId$1 as M, normalizeResolvedSecretInputString as N, jsonResult as O, normalizeSecretInputString as P, registerPluginHttpRoute$1 as R, deliverTextOrMediaReply$1 as S, hasConfiguredSecretInput$1 as T, resolveOpenProviderRuntimeGroupPolicy$1 as U, resolveClientIp as V, resolveWebhookPath$1 as W, warnMissingProviderGroupPolicyFallbackOnce$1 as X, waitForAbortSignal as Y, withResolvedWebhookRequestPipeline as Z, createChannelMessageReplyPipeline as _, WEBHOOK_ANOMALY_COUNTER_DEFAULTS as a, createFixedWindowRateLimiter as b, applyAccountNameToChannelSection as c, buildBaseAccountStatusSnapshot as d, buildChannelConfigSchema as f, chunkTextForOutbound$1 as g, buildTokenChannelStatusSummary$1 as h, PAIRING_APPROVED_MESSAGE as i, migrateBaseNameToDefaultAccount as j, logTypingFailure$1 as k, applyBasicWebhookRequestGuards as l, buildSingleChannelSecretPromptState$1 as m, setZaloRuntime as n, WEBHOOK_RATE_LIMIT_DEFAULTS as o, buildSecretInputSchema as p, sendPayloadWithChunkedTextAndMedia$1 as q, DEFAULT_ACCOUNT_ID$1 as r, addWildcardAllowFrom as s, getZaloRuntime as t, applySetupAccountConfigPatch as u, createChannelPairingController$1 as v, formatPairingApproveHint as w, createWebhookAnomalyTracker as x, createDedupeCache as y, registerWebhookTarget as z };
+export { mergeAllowFromEntries$1 as A, registerWebhookTargetWithPluginRoute as B, formatAllowFromLowercase$1 as C, isNumericTargetId as D, isNormalizedSenderAllowed as E, promptSingleChannelSecretInput$1 as F, resolveWebhookPath$1 as G, resolveDefaultGroupPolicy$1 as H, readJsonWebhookBodyOrReject as I, sendPayloadWithChunkedTextAndMedia$1 as J, resolveWebhookTargetWithAuthOrRejectSync as K, readStringParam as L, normalizeAccountId$1 as M, normalizeResolvedSecretInputString as N, jsonResult as O, normalizeSecretInputString as P, withResolvedWebhookRequestPipeline as Q, registerPluginHttpRoute$1 as R, deliverTextOrMediaReply$1 as S, hasConfiguredSecretInput$1 as T, resolveInboundRouteEnvelopeBuilderWithRuntime$1 as U, resolveClientIp as V, resolveOpenProviderRuntimeGroupPolicy$1 as W, waitForAbortSignal as X, setTopLevelChannelDmPolicyWithAllowFrom as Y, warnMissingProviderGroupPolicyFallbackOnce$1 as Z, createChannelMessageReplyPipeline as _, WEBHOOK_ANOMALY_COUNTER_DEFAULTS as a, createFixedWindowRateLimiter as b, applyAccountNameToChannelSection as c, buildBaseAccountStatusSnapshot as d, buildChannelConfigSchema as f, chunkTextForOutbound$1 as g, buildTokenChannelStatusSummary$1 as h, PAIRING_APPROVED_MESSAGE as i, migrateBaseNameToDefaultAccount as j, logTypingFailure$1 as k, applyBasicWebhookRequestGuards as l, buildSingleChannelSecretPromptState$1 as m, setZaloRuntime as n, WEBHOOK_RATE_LIMIT_DEFAULTS as o, buildSecretInputSchema as p, runSingleChannelSecretStep$1 as q, DEFAULT_ACCOUNT_ID$1 as r, addWildcardAllowFrom$1 as s, getZaloRuntime as t, applySetupAccountConfigPatch as u, createChannelPairingController$1 as v, formatPairingApproveHint as w, createWebhookAnomalyTracker as x, createDedupeCache as y, registerWebhookTarget as z };

package/dist/{secret-contract-Bxvjh0Hq.js → .setup/secret-contract-Bno_huZF.mjs}

@@ -1,10 +1,51 @@
-import { collectConditionalChannelFieldAssignments, createChannelSecretTargetRegistryEntries, getChannelSurface, hasOwnProperty } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+import { collectConditionalChannelFieldAssignments, getChannelSurface, hasOwnProperty } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
 //#region extensions/zalo/src/secret-contract.ts
-const secretTargetRegistryEntries = createChannelSecretTargetRegistryEntries({
-	channelKey: "zalo",
-	account: ["botToken", "webhookSecret"],
-	channel: ["botToken", "webhookSecret"]
-});
+const secretTargetRegistryEntries = [
+	{
+		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
+	}
+];
 function collectRuntimeConfigAssignments(params) {
 	const resolved = getChannelSurface(params.config, "zalo");
 	if (!resolved) return;

package/dist/.setup/secret-contract-api-CILabB_S.mjs

@@ -0,0 +1,3 @@
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries, t as channelSecrets } from "./secret-contract-Bno_huZF.mjs";
+import "../secret-contract-api.js";
+export { channelSecrets, collectRuntimeConfigAssignments, secretTargetRegistryEntries };