@openclaw/zalo 2026.7.2-beta.5 → 2026.8.1-beta.2

package/dist/{actions.runtime-Cqmv6cPB.js → actions.runtime-BRP15DNe.js}

@@ -1,4 +1,4 @@
-import { t as sendMessageZalo } from "./send-BeG5dH7I.js";
+import { t as sendMessageZalo } from "./send-BGGtv8x_.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-qcMoaIyL.js";
-import { t as zaloPlugin } from "./channel-BqA9TbSR.js";
+import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-T6qc2eAG.js";
+import { t as zaloPlugin } from "./channel-Dcp-XLf8.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-BqA9TbSR.js → channel-Dcp-XLf8.js}

@@ -1,4 +1,4 @@
-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-qcMoaIyL.js";
+import { c as inspectZaloAccount, d as resolveZaloAccount, i as zaloSetupContract, l as listZaloAccountIds, p as buildSecretInputSchema, t as createZaloSetupWizardProxy, u as resolveDefaultZaloAccountId } from "./setup-core-T6qc2eAG.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";
@@ -24,14 +24,17 @@ 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-Cqmv6cPB.js"), "zaloActionsRuntime");
+const loadZaloActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-BRP15DNe.js"), "zaloActionsRuntime");
 const providerId = "zalo";
 const ZALO_ACTIONS = /* @__PURE__ */ new Set(["send"]);
 function listEnabledAccounts(cfg, accountId) {
-	return (accountId ? [resolveZaloAccount({
+	return (accountId ? [inspectZaloAccount({
 		cfg,
 		accountId
-	})] : listEnabledZaloAccounts(cfg)).filter((account) => account.enabled && account.tokenSource !== "none");
+	})] : listZaloAccountIds(cfg).map((listedAccountId) => inspectZaloAccount({
+		cfg,
+		accountId: listedAccountId
+	}))).filter((account) => account.enabled && account.tokenStatus === "available");
 }
 const zaloMessageActions = {
 	describeMessageTool: ({ cfg, accountId }) => {
@@ -89,6 +92,7 @@ const zaloApprovalAuth = createChannelApprovalAuth({
 const ZaloConfigSchema = buildMultiAccountChannelSchema(z.object({
 	name: z.string().optional(),
 	enabled: z.boolean().optional(),
+	configWrites: z.boolean().optional(),
 	markdown: MarkdownConfigSchema,
 	botToken: buildSecretInputSchema().optional(),
 	tokenFile: z.string().optional(),
@@ -176,8 +180,8 @@ function looksLikeZaloChatId(raw, normalized) {
 	const target = normalizeZaloMessagingTarget(normalized ?? raw);
 	return Boolean(target);
 }
-const loadZaloChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-D4wDYzqp.js"));
-const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-Cqevy46r.js")).zaloSetupWizard);
+const loadZaloChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-5CivhE5e.js"));
+const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-edfRk3eu.js").then((n) => n.t)).zaloSetupWizard);
 const zaloTextChunkLimit = 2e3;
 async function sendZaloDelivery(ctx) {
 	const result = await (await loadZaloChannelRuntime()).sendZaloText({
@@ -210,6 +214,9 @@ const zaloMessageAdapter = defineChannelMessageAdapter({
 		media: sendZaloDelivery
 	}
 });
+function isZaloAccountConfigured(account) {
+	return account.tokenStatus ? account.tokenStatus !== "missing" : Boolean(account.token?.trim());
+}
 const zaloConfigAdapter = createScopedChannelConfigAdapter({
 	sectionKey: "zalo",
 	listAccountIds: listZaloAccountIds,
@@ -257,7 +264,6 @@ const zaloPlugin = createChatChannelPlugin({
 	base: {
 		id: "zalo",
 		meta,
-		setup: zaloSetupAdapter,
 		setupContract: zaloSetupContract,
 		setupWizard: zaloSetupWizard,
 		capabilities: {
@@ -273,12 +279,16 @@ const zaloPlugin = createChatChannelPlugin({
 		configSchema: buildChannelConfigSchema(ZaloConfigSchema),
 		config: {
 			...zaloConfigAdapter,
-			isConfigured: (account) => Boolean(account.token?.trim()),
+			inspectAccount: adaptScopedAccountAccessor(inspectZaloAccount),
+			isConfigured: isZaloAccountConfigured,
 			describeAccount: (account) => describeWebhookAccountSnapshot({
 				account,
-				configured: Boolean(account.token?.trim()),
+				configured: isZaloAccountConfigured(account),
 				mode: account.config.webhookUrl ? "webhook" : "polling",
-				extra: { tokenSource: account.tokenSource }
+				extra: {
+					tokenSource: account.tokenSource,
+					tokenStatus: account.tokenStatus
+				}
 			})
 		},
 		approvalCapability: zaloApprovalAuth,
@@ -291,6 +301,10 @@ const zaloPlugin = createChatChannelPlugin({
 		messaging: {
 			targetPrefixes: ["zalo", "zl"],
 			normalizeTarget: normalizeZaloMessagingTarget,
+			inferTargetChatType: ({ to }) => {
+				const target = normalizeZaloMessagingTarget(to);
+				return target ? /^group:/i.test(target) ? "group" : "direct" : void 0;
+			},
 			resolveOutboundSessionRoute: (params) => resolveZaloOutboundSessionRoute(params),
 			targetResolver: {
 				looksLikeId: looksLikeZaloChatId,
@@ -315,7 +329,7 @@ const zaloPlugin = createChatChannelPlugin({
 				timeoutMs
 			}),
 			resolveAccountSnapshot: ({ account }) => {
-				const configured = Boolean(account.token?.trim());
+				const configured = isZaloAccountConfigured(account);
 				return {
 					accountId: account.accountId,
 					name: account.name,
@@ -323,6 +337,7 @@ const zaloPlugin = createChatChannelPlugin({
 					configured,
 					extra: {
 						tokenSource: account.tokenSource,
+						tokenStatus: account.tokenStatus,
 						mode: account.config.webhookUrl ? "webhook" : "polling",
 						dmPolicy: account.config.dmPolicy ?? "pairing"
 					}

package/dist/channel-plugin-api.js

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

package/dist/{channel.runtime-D4wDYzqp.js → channel.runtime-5CivhE5e.js}

@@ -1,58 +1,41 @@
-import { m as normalizeSecretInputString } from "./setup-core-qcMoaIyL.js";
+import { m as normalizeSecretInputString } from "./setup-core-T6qc2eAG.js";
 import { i as PAIRING_APPROVED_MESSAGE } from "./runtime-api-qxdOyk3M.js";
-import { a as getMe, n as resolveZaloProxyFetch, r as ZaloApiError, t as sendMessageZalo } from "./send-BeG5dH7I.js";
+import { a as getMe, n as resolveZaloProxyFetch, r as ZaloApiError, t as sendMessageZalo } from "./send-BGGtv8x_.js";
 import { createAccountStatusSink } from "openclaw/plugin-sdk/channel-outbound";
+import { runChannelProbe } from "openclaw/plugin-sdk/text-utility-runtime";
 //#region extensions/zalo/src/probe.ts
+function formatZaloProbeError(error, timeoutMs) {
+	if (error instanceof ZaloApiError) return error.description ?? error.message;
+	if (error instanceof Error) return error.name === "AbortError" ? `Request timed out after ${timeoutMs}ms` : error.message;
+	return String(error);
+}
 async function probeZalo(token, timeoutMs = 5e3, fetcher) {
 	if (!token?.trim()) return {
 		ok: false,
 		error: "No token provided",
 		elapsedMs: 0
 	};
-	const startTime = Date.now();
-	try {
+	return await runChannelProbe(void 0, async ({ elapsedMs }) => {
 		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
+			elapsedMs: 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
+			elapsedMs: 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
-		};
-	}
+	}, (error) => ({
+		ok: false,
+		error: formatZaloProbeError(error, timeoutMs)
+	}));
 }
 //#endregion
 //#region extensions/zalo/src/channel.runtime.ts
 async function notifyZaloPairingApproval(params) {
-	const { resolveZaloAccount } = await import("./setup-core-qcMoaIyL.js").then((n) => n.s);
+	const { resolveZaloAccount } = await import("./setup-core-T6qc2eAG.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 +69,7 @@ async function startZaloGatewayAccount(ctx) {
 		setStatus: ctx.setStatus
 	});
 	ctx.log?.info(`[${account.accountId}] starting provider${zaloBotLabel} mode=${mode}`);
-	const { monitorZaloProvider } = await import("./monitor-DvrLTTtn.js");
+	const { monitorZaloProvider } = await import("./monitor-Ckz5Mo22.js");
 	return monitorZaloProvider({
 		token,
 		account,

package/dist/{monitor-DvrLTTtn.js → monitor-Ckz5Mo22.js}

@@ -1,16 +1,18 @@
 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-BeG5dH7I.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-BGGtv8x_.js";
+import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 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";
 import { createChannelPairingController } from "openclaw/plugin-sdk/channel-pairing";
 import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
-import { registerPluginHttpRoute, resolveWebhookPath } from "openclaw/plugin-sdk/webhook-ingress";
+import { canonicalizeWebhookRouteKey, 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 { createChannelPartialDeliveryError, formatInboundMediaUnavailableText, resolveChannelInboundRouteEnvelope } from "openclaw/plugin-sdk/channel-inbound";
 import { resolveStableChannelMessageIngress } from "openclaw/plugin-sdk/channel-ingress-runtime";
+import { channelReadyPatch } from "openclaw/plugin-sdk/gateway-runtime";
 import { sleepWithAbort, waitForAbortSignal } from "openclaw/plugin-sdk/runtime-env";
 import { createHostedOutboundMediaStore } from "openclaw/plugin-sdk/outbound-media";
 import { safeEqualSecret } from "openclaw/plugin-sdk/security-runtime";
@@ -115,35 +117,44 @@ async function tryHandleHostedZaloMediaRequest(req, res) {
 		res.end("Expired");
 		return true;
 	}
-	const entry = await store.read(id, now);
-	if (!entry || entry.metadata.routePath !== routePath) {
+	const metadata = await store.readMetadata(id, now);
+	if (!metadata || metadata.routePath !== routePath) {
 		res.statusCode = 404;
 		res.end("Not Found");
 		return true;
 	}
-	const expiresAt = asDateTimestampMs(entry.metadata.expiresAt);
+	const expiresAt = asDateTimestampMs(metadata.expiresAt);
 	if (expiresAt === void 0 || expiresAt <= now) {
 		await store.delete(id);
 		res.statusCode = 410;
 		res.end("Expired");
 		return true;
 	}
-	if (!safeEqualSecret(url.searchParams.get("token"), entry.metadata.token)) {
+	const token = url.searchParams.get("token");
+	if (!safeEqualSecret(token, metadata.token)) {
 		res.statusCode = 401;
 		res.end("Unauthorized");
 		return true;
 	}
-	if (entry.metadata.contentType) res.setHeader("Content-Type", entry.metadata.contentType);
+	let servedMetadata = metadata;
+	let body;
+	if (method === "GET") {
+		const entry = await store.read(id, now);
+		if (!entry || entry.metadata.routePath !== routePath || !safeEqualSecret(token, entry.metadata.token)) {
+			res.statusCode = 404;
+			res.end("Not Found");
+			return true;
+		}
+		servedMetadata = entry.metadata;
+		body = entry.buffer;
+	}
+	if (servedMetadata.contentType) res.setHeader("Content-Type", servedMetadata.contentType);
 	res.setHeader("Cache-Control", "no-store");
 	res.setHeader("X-Content-Type-Options", "nosniff");
-	res.setHeader("Content-Length", String(entry.metadata.byteLength));
-	if (method === "HEAD") {
-		res.statusCode = 200;
-		res.end();
-		return true;
-	}
+	res.setHeader("Content-Length", String(servedMetadata.byteLength));
 	res.statusCode = 200;
-	res.end(entry.buffer);
+	res.end(body);
+	if (method === "HEAD") return true;
 	await store.delete(id);
 	return true;
 }
@@ -163,31 +174,23 @@ function resolveZaloTimestampMs(date) {
 	if (!date) return;
 	return date >= UNIX_MILLISECONDS_THRESHOLD ? date : date * 1e3;
 }
-const loadZaloWebhookRuntime = createLazyRuntimeNamedExport(() => import("./monitor.webhook-BfWVHoMH.js"), "zaloWebhookRuntime");
-const loadZaloWebhookIngressRuntime = createLazyRuntimeNamedExport(() => import("./webhook-spool-D9q-q0oh.js"), "zaloWebhookIngressRuntime");
+const loadZaloWebhookRuntime = createLazyRuntimeNamedExport(() => import("./monitor.webhook-S7nThy3R.js"), "zaloWebhookRuntime");
+const loadZaloWebhookIngressRuntime = createLazyRuntimeNamedExport(() => import("./webhook-spool-Bf17xwqi.js"), "zaloWebhookIngressRuntime");
 const loadZaloWebhookModule = createLazyRuntimeModule(async () => ({
 	...await loadZaloWebhookRuntime(),
 	...await loadZaloWebhookIngressRuntime()
 }));
-function releaseSharedHostedMediaRouteRef(routePath) {
-	const current = hostedMediaRouteRefs.get(routePath);
-	if (!current) return;
-	if (current.count > 1) {
-		current.count -= 1;
-		return;
-	}
-	hostedMediaRouteRefs.delete(routePath);
-	for (const unregisterHandle of current.unregisters) unregisterHandle();
-}
 function registerSharedHostedMediaRoute(params) {
+	const routeKey = canonicalizeWebhookRouteKey(params.path);
 	const unregister = registerPluginHttpRoute({
 		auth: "plugin",
 		match: "prefix",
 		path: params.path,
 		pluginId: "zalo",
 		source: "zalo-hosted-media",
-		accountId: params.accountId,
 		log: params.log,
+		reuseExistingSameOwner: true,
+		throwOnFailure: true,
 		handler: async (req, res) => {
 			if (!await tryHandleHostedZaloMediaRequest(req, res) && !res.headersSent) {
 				res.statusCode = 404;
@@ -196,17 +199,23 @@ function registerSharedHostedMediaRoute(params) {
 			}
 		}
 	});
-	const existing = hostedMediaRouteRefs.get(params.path);
-	if (existing) {
-		existing.count += 1;
-		existing.unregisters.push(unregister);
-		return () => releaseSharedHostedMediaRouteRef(params.path);
-	}
-	hostedMediaRouteRefs.set(params.path, {
-		count: 1,
-		unregisters: [unregister]
-	});
-	return () => releaseSharedHostedMediaRouteRef(params.path);
+	const acquired = hostedMediaRouteRefs.get(routeKey) ?? {
+		count: 0,
+		unregisters: []
+	};
+	if (acquired.count === 0) hostedMediaRouteRefs.set(routeKey, acquired);
+	acquired.count += 1;
+	acquired.unregisters.push(unregister);
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (hostedMediaRouteRefs.get(routeKey) !== acquired) return;
+		acquired.count -= 1;
+		if (acquired.count > 0) return;
+		hostedMediaRouteRefs.delete(routeKey);
+		for (const unregisterHandle of acquired.unregisters) unregisterHandle();
+	};
 }
 function formatZaloError(error) {
 	if (error instanceof Error) return error.stack ?? `${error.name}: ${error.message}`;
@@ -253,6 +262,7 @@ function startPollingLoop(params) {
 		try {
 			const response = await getUpdates(token, { timeout: pollTimeout }, fetcher);
 			if (isStopped() || abortSignal.aborted) return;
+			if (response.ok) statusSink?.(channelReadyPatch());
 			if (response.ok && response.result) {
 				statusSink?.({ lastInboundAt: Date.now() });
 				await processUpdate({
@@ -262,7 +272,13 @@ 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)}`);
+				const error = formatZaloError(err);
+				runtime.error?.(`[${account.accountId}] Zalo polling error: ${error}`);
+				statusSink?.({
+					connected: false,
+					lifecycle: "recovering",
+					lastError: error
+				});
 				await sleepWithAbort(5e3, abortSignal).catch(() => void 0);
 			}
 		}
@@ -385,7 +401,7 @@ async function authorizeZaloMessage(params) {
 		defaultGroupPolicy
 	});
 	const shouldComputeAuth = core.channel.commands.shouldComputeCommandAuthorized(rawBody, config);
-	const access = await resolveStableChannelMessageIngress({
+	const resolveChannelIngress = async (contextBinding) => await resolveStableChannelMessageIngress({
 		channelId: "zalo",
 		accountId: account.accountId,
 		identity: {
@@ -401,6 +417,7 @@ async function authorizeZaloMessage(params) {
 			kind: isGroup ? "group" : "direct",
 			id: chatId
 		},
+		contextBinding,
 		providerMissingFallbackApplied,
 		dmPolicy,
 		groupPolicy,
@@ -409,6 +426,7 @@ async function authorizeZaloMessage(params) {
 		groupAllowFrom: normalizeStringEntries(account.config.groupAllowFrom),
 		command: shouldComputeAuth ? {} : void 0
 	});
+	const access = await resolveChannelIngress();
 	const senderAccess = access.senderAccess;
 	if (isGroup) {
 		warnMissingProviderGroupPolicyFallbackOnce({
@@ -451,6 +469,8 @@ async function authorizeZaloMessage(params) {
 		return;
 	}
 	return {
+		channelIngress: access,
+		resolveChannelIngress,
 		chatId,
 		commandAuthorized: access.commandAccess.requested ? access.commandAccess.authorized : void 0,
 		isGroup,
@@ -468,7 +488,7 @@ async function processMessageWithPipeline(params) {
 		mediaType
 	});
 	if (!authorization) return;
-	const { isGroup, chatId, senderId, senderName, rawBody, commandAuthorized } = authorization;
+	const { isGroup, chatId, senderId, senderName, rawBody } = authorization;
 	const agentBody = agentBodyOverride ?? rawBody;
 	const { route, buildEnvelope } = resolveChannelInboundRouteEnvelope({
 		cfg: config,
@@ -479,6 +499,17 @@ async function processMessageWithPipeline(params) {
 			id: chatId
 		}
 	});
+	const channelIngress = await authorization.resolveChannelIngress({
+		agentId: route.agentId,
+		sessionKey: route.sessionKey,
+		messageId: message_id,
+		inboundEventKind: "user_request"
+	});
+	if (!channelIngress.senderAccess.allowed) {
+		logVerbose(core, runtime, `zalo: authorization changed before dispatch for ${senderId}`);
+		return;
+	}
+	const commandAuthorized = channelIngress.commandAccess.requested ? channelIngress.commandAccess.authorized : void 0;
 	if (isGroup && core.channel.commands.isControlCommandMessage(rawBody, config) && commandAuthorized !== true) {
 		logVerbose(core, runtime, `zalo: drop control command from unauthorized sender ${senderId}`);
 		return;
@@ -492,6 +523,7 @@ async function processMessageWithPipeline(params) {
 		body: agentBody
 	});
 	const ctxPayload = core.channel.inbound.buildContext({
+		channelIngress,
 		channel: "zalo",
 		accountId: route.accountId,
 		messageId: message_id,
@@ -561,7 +593,6 @@ async function processMessageWithPipeline(params) {
 					payload,
 					token,
 					chatId,
-					runtime,
 					core,
 					config,
 					webhookUrl: params.webhookUrl,
@@ -575,8 +606,8 @@ async function processMessageWithPipeline(params) {
 					tableMode: "off"
 				});
 			},
-			onDelivered: () => {
-				statusSink?.({ lastOutboundAt: Date.now() });
+			onDelivered: (_payload, _info, result) => {
+				if (result?.visibleReplySent !== false) statusSink?.({ lastOutboundAt: Date.now() });
 			},
 			onError: (err, info) => {
 				runtime.error?.(`[${account.accountId}] Zalo ${info.kind} reply failed: ${String(err)}`);
@@ -606,49 +637,64 @@ async function processMessageWithPipeline(params) {
 	});
 }
 async function deliverZaloReply(params) {
-	const { payload, token, chatId, runtime, core, config, webhookUrl, webhookPath, proxyUrl, mediaMaxBytes, canHostMedia, accountId, statusSink, fetcher } = params;
+	const { payload, token, chatId, core, config, webhookUrl, webhookPath, proxyUrl, mediaMaxBytes, canHostMedia, accountId, statusSink, fetcher } = params;
 	const tableMode = params.tableMode ?? "code";
 	const reply = resolveSendableOutboundReplyParts(payload, { text: core.channel.text.convertMarkdownTables(payload.text ?? "", tableMode) });
 	const chunkMode = core.channel.text.resolveChunkMode(config, "zalo", accountId);
-	await deliverTextOrMediaReply({
-		payload,
-		text: reply.text,
-		chunkText: (value) => core.channel.text.chunkMarkdownTextWithMode(value, ZALO_TEXT_LIMIT, chunkMode),
-		sendText: async (chunk) => {
-			try {
-				await sendMessage(token, {
+	const acceptedMessageIds = [];
+	let visibleReplySent = false;
+	const recordAcceptedSend = (result) => {
+		const messageId = result.result?.message_id;
+		if (messageId) acceptedMessageIds.push(messageId);
+		visibleReplySent = true;
+		statusSink?.({ lastOutboundAt: Date.now() });
+	};
+	try {
+		await deliverTextOrMediaReply({
+			payload,
+			text: reply.text,
+			chunkText: (value) => core.channel.text.chunkMarkdownTextWithMode(value, ZALO_TEXT_LIMIT, chunkMode),
+			sendText: async (chunk) => {
+				recordAcceptedSend(await sendMessage(token, {
 					chat_id: chatId,
 					text: chunk
-				}, fetcher);
-				statusSink?.({ lastOutboundAt: Date.now() });
-			} catch (err) {
-				runtime.error?.(`Zalo message send failed: ${String(err)}`);
+				}, fetcher));
+			},
+			sendMedia: async ({ mediaUrl, caption }) => {
+				const sendableMediaUrl = canHostMedia && webhookUrl && webhookPath ? await prepareHostedZaloMediaUrl({
+					mediaUrl,
+					webhookUrl,
+					webhookPath,
+					maxBytes: mediaMaxBytes,
+					proxyUrl
+				}) : mediaUrl;
+				recordAcceptedSend(await sendPhoto(token, {
+					chat_id: chatId,
+					photo: sendableMediaUrl,
+					caption
+				}, fetcher));
 			}
-		},
-		sendMedia: async ({ mediaUrl, caption }) => {
-			const sendableMediaUrl = canHostMedia && webhookUrl && webhookPath ? await prepareHostedZaloMediaUrl({
-				mediaUrl,
-				webhookUrl,
-				webhookPath,
-				maxBytes: mediaMaxBytes,
-				proxyUrl
-			}) : mediaUrl;
-			await sendPhoto(token, {
-				chat_id: chatId,
-				photo: sendableMediaUrl,
-				caption
-			}, fetcher);
-			statusSink?.({ lastOutboundAt: Date.now() });
-		},
-		onMediaError: (error) => {
-			runtime.error?.(`Zalo photo send failed: ${error instanceof Error ? error.message : JSON.stringify(error)}`);
-		}
-	});
+		});
+	} catch (error) {
+		if (!visibleReplySent) throw error;
+		throw createChannelPartialDeliveryError(error, {
+			messageIds: acceptedMessageIds,
+			receipt: createMessageReceiptFromOutboundResults({
+				results: acceptedMessageIds.map((messageId) => ({
+					channel: "zalo",
+					messageId
+				})),
+				kind: reply.hasMedia ? "media" : "text"
+			}),
+			visibleReplySent: true
+		});
+	}
 }
 async function monitorZaloProvider(options) {
 	const { token, account, config, runtime, abortSignal, useWebhook, webhookUrl, webhookSecret, webhookPath, statusSink, fetcher: fetcherOverride } = options;
 	const core = getZaloRuntime();
-	const effectiveMediaMaxMb = account.config.mediaMaxMb ?? DEFAULT_MEDIA_MAX_MB;
+	const configuredMediaMaxMb = account.config.mediaMaxMb;
+	const effectiveMediaMaxMb = typeof configuredMediaMaxMb === "number" && configuredMediaMaxMb > 0 ? configuredMediaMaxMb : DEFAULT_MEDIA_MAX_MB;
 	const fetcher = fetcherOverride ?? resolveZaloProxyFetch(account.config.proxy);
 	const mode = useWebhook ? "webhook" : "polling";
 	const effectiveWebhookUrl = normalizeWebhookUrl(webhookUrl ?? account.config.webhookUrl);
@@ -674,13 +720,16 @@ 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 {
 		if (hostedMediaRoutePath) {
 			const unregisterHostedMediaRoute = registerSharedHostedMediaRoute({
 				path: hostedMediaRoutePath,
-				accountId: account.accountId,
 				log: runtime.log
 			});
 			stopHandlers.push(unregisterHostedMediaRoute);
@@ -731,6 +780,7 @@ async function monitorZaloProvider(options) {
 				source: "zalo-webhook",
 				accountId: account.accountId,
 				log: runtime.log,
+				throwOnFailure: true,
 				handler: async (req, res) => {
 					if (!await handleZaloWebhookRequest(req, res) && !res.headersSent) {
 						res.statusCode = 404;
@@ -744,6 +794,7 @@ async function monitorZaloProvider(options) {
 				url: effectiveWebhookUrl,
 				secret_token: webhookSecret
 			}, fetcher);
+			statusSink?.(channelReadyPatch());
 			let webhookCleanupPromise;
 			cleanupWebhook = async () => {
 				if (!webhookCleanupPromise) webhookCleanupPromise = (async () => {
@@ -796,7 +847,13 @@ async function monitorZaloProvider(options) {
 		});
 		await waitForAbortSignal(abortSignal);
 	} catch (err) {
-		runtime.error?.(`[${account.accountId}] Zalo provider startup failed mode=${mode}: ${formatZaloError(err)}`);
+		const error = formatZaloError(err);
+		runtime.error?.(`[${account.accountId}] Zalo provider startup failed mode=${mode}: ${error}`);
+		statusSink?.({
+			connected: false,
+			lifecycle: "recovering",
+			lastError: error
+		});
 		throw err;
 	} finally {
 		abortSignal.removeEventListener("abort", stopOnAbort);

package/dist/{monitor.webhook-BfWVHoMH.js → monitor.webhook-S7nThy3R.js}

@@ -1,8 +1,10 @@
 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-D9q-q0oh.js";
+import { ZaloWebhookPayloadError } from "./webhook-spool-Bf17xwqi.js";
 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 webhookTargets = /* @__PURE__ */ new Map();
 const webhookRateLimiter = createFixedWindowRateLimiter({
 	windowMs: WEBHOOK_RATE_LIMIT_DEFAULTS.windowMs,
@@ -18,9 +20,6 @@ function clearZaloWebhookSecurityStateForTest() {
 	webhookRateLimiter.clear();
 	webhookAnomalyTracker.clear();
 }
-function getZaloWebhookRateLimitStateSizeForTest() {
-	return webhookRateLimiter.size();
-}
 function getZaloWebhookStatusCounterSizeForTest() {
 	return webhookAnomalyTracker.size();
 }
@@ -108,6 +107,7 @@ async function handleZaloWebhookRequest(req, res) {
 				target.runtime.error?.(`[${target.account.accountId}] Zalo webhook admission failed: ${String(error)}`);
 				return true;
 			}
+			res.setHeader(ZALO_WEBHOOK_ACCEPTED_HEADER, ZALO_WEBHOOK_ACCEPTED_VALUE);
 			res.statusCode = 200;
 			res.end("ok");
 			return true;
@@ -116,7 +116,6 @@ async function handleZaloWebhookRequest(req, res) {
 }
 const zaloWebhookRuntime = {
 	clearZaloWebhookSecurityStateForTest,
-	getZaloWebhookRateLimitStateSizeForTest,
 	getZaloWebhookStatusCounterSizeForTest,
 	handleZaloWebhookRequest,
 	registerZaloWebhookTarget

package/dist/{send-BeG5dH7I.js → send-BGGtv8x_.js}

@@ -1,5 +1,6 @@
-import { d as resolveZaloAccount, f as resolveZaloToken } from "./setup-core-qcMoaIyL.js";
+import { d as resolveZaloAccount, f as resolveZaloToken } from "./setup-core-T6qc2eAG.js";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
+import { stripChannelTargetPrefix, stripTargetKindPrefix } from "openclaw/plugin-sdk/core";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
@@ -231,7 +232,7 @@ function resolveValidatedSendContext(chatId, options) {
 		ok: false,
 		error: "No Zalo bot token configured"
 	};
-	const trimmedChatId = chatId?.trim();
+	const trimmedChatId = normalizeZaloSendChatId(chatId);
 	if (!trimmedChatId) return {
 		ok: false,
 		error: "No chat_id provided"
@@ -243,6 +244,9 @@ function resolveValidatedSendContext(chatId, options) {
 		fetcher
 	};
 }
+function normalizeZaloSendChatId(chatId) {
+	return stripTargetKindPrefix(stripChannelTargetPrefix(chatId, "zalo", "zl"));
+}
 function resolveSendContextOrFailure(chatId, options) {
 	const context = resolveValidatedSendContext(chatId, options);
 	return context.ok ? { context } : { failure: {

package/dist/setup-api.js

@@ -1,4 +1,4 @@
-import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-qcMoaIyL.js";
+import { n as zaloDmPolicy, r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-T6qc2eAG.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
@@ -23,7 +23,7 @@ function createLazyObjectValue(load) {
 	});
 }
 function loadSetupSurfaceModule() {
-	return loadBundledEntryExportSync(import.meta.url, { specifier: "./src/setup-surface.js" });
+	return loadBundledEntryExportSync(import.meta.url, { specifier: "./setup-surface.js" });
 }
 const zaloSetupWizard = createLazyObjectValue(() => loadSetupSurfaceModule().zaloSetupWizard);
 //#endregion

package/dist/{setup-core-qcMoaIyL.js → setup-core-T6qc2eAG.js}

@@ -3,10 +3,10 @@ import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/acco
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 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 { buildSecretInputSchema, normalizeSecretInputString, resolveSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
 import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createDelegatedSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, formatDocsLink, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/setup";
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, createDelegatedSetupWizardProxy, createPatchedAccountSetupAdapter, createSetupInputPresenceValidator, createSetupTranslator, formatDocsLink, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, patchScopedAccountConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -30,58 +30,77 @@ function resolveZaloToken(config, accountId, options) {
 	const accountConfig = resolveAccountEntry(baseConfig?.accounts, normalizeAccountId(resolvedAccountId));
 	const accountHasBotToken = Boolean(accountConfig && Object.hasOwn(accountConfig, "botToken"));
 	if (accountConfig && accountHasBotToken) {
-		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(accountConfig.botToken) : normalizeResolvedSecretInputString({
+		const token = resolveSecretInputString({
 			value: accountConfig.botToken,
-			path: `channels.zalo.accounts.${resolvedAccountId}.botToken`
+			path: `channels.zalo.accounts.${resolvedAccountId}.botToken`,
+			mode: options?.mode
 		});
-		if (token) return {
-			token,
-			source: "config"
+		if (token.status === "available") return {
+			token: token.value,
+			source: "config",
+			status: "available"
+		};
+		if (token.status === "configured_unavailable") return {
+			token: "",
+			source: "config",
+			status: "configured_unavailable"
 		};
 		const fileToken = readTokenFromFile(accountConfig.tokenFile);
 		if (fileToken) return {
 			token: fileToken,
-			source: "configFile"
+			source: "configFile",
+			status: "available"
 		};
 	}
 	if (!accountHasBotToken) {
 		const fileToken = readTokenFromFile(accountConfig?.tokenFile);
 		if (fileToken) return {
 			token: fileToken,
-			source: "configFile"
+			source: "configFile",
+			status: "available"
 		};
 	}
 	if (!accountHasBotToken) {
-		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(baseConfig?.botToken) : normalizeResolvedSecretInputString({
+		const token = resolveSecretInputString({
 			value: baseConfig?.botToken,
-			path: "channels.zalo.botToken"
+			path: "channels.zalo.botToken",
+			mode: options?.mode
 		});
-		if (token) return {
-			token,
-			source: "config"
+		if (token.status === "available") return {
+			token: token.value,
+			source: "config",
+			status: "available"
+		};
+		if (token.status === "configured_unavailable") return {
+			token: "",
+			source: "config",
+			status: "configured_unavailable"
 		};
 		const fileToken = readTokenFromFile(baseConfig?.tokenFile);
 		if (fileToken) return {
 			token: fileToken,
-			source: "configFile"
+			source: "configFile",
+			status: "available"
 		};
 	}
 	if (isDefaultAccount) {
 		const envToken = process.env.ZALO_BOT_TOKEN?.trim();
 		if (envToken) return {
 			token: envToken,
-			source: "env"
+			source: "env",
+			status: "available"
 		};
 	}
 	return {
 		token: "",
-		source: "none"
+		source: "none",
+		status: "missing"
 	};
 }
 //#endregion
 //#region extensions/zalo/src/accounts.ts
 var accounts_exports = /* @__PURE__ */ __exportAll({
-	listEnabledZaloAccounts: () => listEnabledZaloAccounts,
+	inspectZaloAccount: () => inspectZaloAccount,
 	listZaloAccountIds: () => listZaloAccountIds,
 	resolveDefaultZaloAccountId: () => resolveDefaultZaloAccountId,
 	resolveZaloAccount: () => resolveZaloAccount
@@ -93,27 +112,34 @@ const { listAccountIds: listZaloAccountIds, resolveDefaultAccountId: resolveDefa
 		envVars: ["ZALO_BOT_TOKEN"]
 	}
 });
-function resolveZaloAccount(params) {
+function resolveZaloAccountWithMode(params) {
 	const accountId = normalizeAccountId(params.accountId ?? (params.cfg.channels?.zalo)?.defaultAccount);
 	const baseEnabled = (params.cfg.channels?.zalo)?.enabled !== false;
 	const merged = mergeZaloAccountConfig(params.cfg, accountId);
 	const accountEnabled = merged.enabled !== false;
 	const enabled = baseEnabled && accountEnabled;
-	const tokenResolution = resolveZaloToken(params.cfg.channels?.zalo, accountId, { allowUnresolvedSecretRef: params.allowUnresolvedSecretRef });
+	const tokenResolution = resolveZaloToken(params.cfg.channels?.zalo, accountId, { mode: params.mode });
 	return {
 		accountId,
 		name: normalizeOptionalString(merged.name),
 		enabled,
 		token: tokenResolution.token,
 		tokenSource: tokenResolution.source,
+		tokenStatus: tokenResolution.status,
 		config: merged
 	};
 }
-function listEnabledZaloAccounts(cfg) {
-	return listZaloAccountIds(cfg).map((accountId) => resolveZaloAccount({
-		cfg,
-		accountId
-	})).filter((account) => account.enabled);
+function resolveZaloAccount(params) {
+	return resolveZaloAccountWithMode({
+		...params,
+		mode: "strict"
+	});
+}
+function inspectZaloAccount(params) {
+	return resolveZaloAccountWithMode({
+		...params,
+		mode: "inspect"
+	});
 }
 //#endregion
 //#region extensions/zalo/src/setup-allow-from.ts
@@ -218,7 +244,8 @@ const zaloSetupContract = defineChannelSetupContract({
 			cli: {
 				flags: "--use-env",
 				description: "Use ZALO_BOT_TOKEN"
-			}
+			},
+			envVars: ["ZALO_BOT_TOKEN"]
 		}
 	},
 	legacyAdapter: zaloSetupAdapter
@@ -232,38 +259,12 @@ const zaloDmPolicy = createChannelDmPolicy({
 			accountId: accountId && normalizeAccountId$1(accountId) ? normalizeAccountId$1(accountId) ?? DEFAULT_ACCOUNT_ID$1 : resolveDefaultZaloAccountId(cfg)
 		});
 	},
-	applyPatch: ({ cfg, account, patch }) => {
-		if (account.accountId === DEFAULT_ACCOUNT_ID$1) return {
-			...cfg,
-			channels: {
-				...cfg.channels,
-				zalo: {
-					...cfg.channels?.zalo,
-					enabled: true,
-					...patch
-				}
-			}
-		};
-		const currentAccount = cfg.channels?.zalo?.accounts?.[account.accountId];
-		return {
-			...cfg,
-			channels: {
-				...cfg.channels,
-				zalo: {
-					...cfg.channels?.zalo,
-					enabled: true,
-					accounts: {
-						...cfg.channels?.zalo?.accounts,
-						[account.accountId]: {
-							...currentAccount,
-							enabled: currentAccount?.enabled ?? true,
-							...patch
-						}
-					}
-				}
-			}
-		};
-	},
+	applyPatch: ({ cfg, account, patch }) => patchScopedAccountConfig({
+		cfg,
+		channelKey: channel,
+		accountId: account.accountId,
+		patch
+	}),
 	promptAllowFrom: async ({ cfg, prompter, accountId }) => promptZaloAllowFrom({
 		cfg,
 		prompter,
@@ -285,17 +286,8 @@ function createZaloSetupWizardProxy(loadWizard) {
 		credentials: [],
 		delegateFinalize: true,
 		dmPolicy: zaloDmPolicy,
-		disable: (cfg) => ({
-			...cfg,
-			channels: {
-				...cfg.channels,
-				zalo: {
-					...cfg.channels?.zalo,
-					enabled: false
-				}
-			}
-		})
+		disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
 	});
 }
 //#endregion
-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 };
+export { noteZaloTokenHelp as a, inspectZaloAccount as c, resolveZaloAccount as d, resolveZaloToken as f, __exportAll as h, 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-Cqevy46r.js → setup-surface-edfRk3eu.js}

@@ -1,6 +1,7 @@
-import { a as noteZaloTokenHelp, d as resolveZaloAccount, n as zaloDmPolicy, o as promptZaloAllowFrom } from "./setup-core-qcMoaIyL.js";
+import { a as noteZaloTokenHelp, c as inspectZaloAccount, h as __exportAll, n as zaloDmPolicy, o as promptZaloAllowFrom } from "./setup-core-T6qc2eAG.js";
 import { DEFAULT_ACCOUNT_ID, buildSingleChannelSecretPromptState, createSetupTranslator, createStandardChannelSetupStatus, hasConfiguredSecretInput, promptSingleChannelSecretInput, runSingleChannelSecretStep } from "openclaw/plugin-sdk/setup";
 //#region extensions/zalo/src/setup-surface.ts
+var setup_surface_exports = /* @__PURE__ */ __exportAll({ zaloSetupWizard: () => zaloSetupWizard });
 const t = createSetupTranslator();
 const channel = "zalo";
 function setZaloUpdateMode(cfg, accountId, mode, webhookUrl, webhookSecret, webhookPath) {
@@ -72,10 +73,9 @@ const zaloSetupWizard = {
 		unconfiguredScore: 10,
 		includeStatusLine: true,
 		resolveConfigured: ({ cfg, accountId }) => {
-			const account = resolveZaloAccount({
+			const account = inspectZaloAccount({
 				cfg,
-				accountId,
-				allowUnresolvedSecretRef: true
+				accountId
 			});
 			return Boolean(account.token) || hasConfiguredSecretInput(account.config.botToken) || Boolean(account.config.tokenFile?.trim());
 		}
@@ -83,10 +83,9 @@ const zaloSetupWizard = {
 	credentials: [],
 	finalize: async ({ cfg, accountId, forceAllowFrom, options, prompter }) => {
 		let next = cfg;
-		const resolvedAccount = resolveZaloAccount({
+		const resolvedAccount = inspectZaloAccount({
 			cfg: next,
-			accountId,
-			allowUnresolvedSecretRef: true
+			accountId
 		});
 		const accountConfigured = Boolean(resolvedAccount.token);
 		const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
@@ -213,4 +212,4 @@ const zaloSetupWizard = {
 	dmPolicy: zaloDmPolicy
 };
 //#endregion
-export { zaloSetupWizard };
+export { zaloSetupWizard as n, setup_surface_exports as t };

package/dist/setup-surface.js

@@ -0,0 +1,3 @@
+import { r as zaloSetupAdapter } from "./setup-core-T6qc2eAG.js";
+import { n as zaloSetupWizard } from "./setup-surface-edfRk3eu.js";
+export { zaloSetupAdapter, zaloSetupWizard };

package/dist/{webhook-spool-D9q-q0oh.js → webhook-spool-Bf17xwqi.js}

@@ -1,28 +1,15 @@
 import { t as getZaloRuntime } from "./runtime-api-qxdOyk3M.js";
-import { r as ZaloApiError } from "./send-BeG5dH7I.js";
-import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressMonitor } from "openclaw/plugin-sdk/channel-outbound";
+import { r as ZaloApiError } from "./send-BGGtv8x_.js";
+import { DEFAULT_INGRESS_ADOPTION_STALL_MS, DEFAULT_INGRESS_RETRY_MAX_ATTEMPTS, bindIngressLifecycleToReplyOptions, createChannelIngressError, createChannelIngressMonitor } from "openclaw/plugin-sdk/channel-outbound";
+import { normalizeNullableString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { isRecord } from "openclaw/plugin-sdk/channel-secret-basic-runtime";
+import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
 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;
-}
+const ZaloWebhookPayloadError = createChannelIngressError("ZaloWebhookPayloadError");
 function parseRawRecord(rawEvent) {
 	let parsed;
 	try {
@@ -40,9 +27,9 @@ function resolveUpdateRecord(envelope) {
 function inspectZaloWebhookEvent(rawEvent) {
 	const update = resolveUpdateRecord(parseRawRecord(rawEvent));
 	const message = isRecord(update.message) ? update.message : null;
-	const eventId = nonEmptyString(message?.message_id);
+	const eventId = normalizeNullableString(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);
+	const chatId = normalizeNullableString((isRecord(message?.chat) ? message.chat : null)?.id);
 	if (!chatId) throw new ZaloWebhookPayloadError("Zalo webhook message is missing message.chat.id.");
 	return {
 		eventId,
@@ -54,20 +41,17 @@ 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);
+	const eventName = normalizeNullableString(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 (!normalizeNullableString(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();
@@ -80,10 +64,8 @@ function isZaloAuthenticationFailure(error) {
 	return false;
 }
 function createZaloWebhookIngress(options) {
-	const queue = options.queue ?? getZaloRuntime().state.openChannelIngressQueue({ accountId: options.accountId });
-	const deferredClaims = /* @__PURE__ */ new Map();
 	const monitor = createChannelIngressMonitor({
-		queue,
+		queue: options.queue ?? getZaloRuntime().state.openChannelIngressQueue({ accountId: options.accountId }),
 		inspect: (rawEvent) => inspectZaloWebhookEvent(rawEvent),
 		payload: {
 			storage: "raw-event",
@@ -94,47 +76,13 @@ function createZaloWebhookIngress(options) {
 		},
 		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" };
+			await options.deliver(update, bindIngressLifecycleToReplyOptions(lifecycle).turnAdoptionLifecycle);
 		},
 		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
-		},
+		retention: { failedMaxEntries: 5e3 },
 		waitForDeliveryIdleBeforeRepump: false,
 		runPumpTask: runDetachedWebhookWork,
+		deferredClaims: "wait-on-stop",
 		drain: {
 			adoptionStallTimeoutMs: DEFAULT_INGRESS_ADOPTION_STALL_MS,
 			startLimit: ZALO_WEBHOOK_MAX_CONCURRENT_DELIVERIES,
@@ -149,24 +97,21 @@ function createZaloWebhookIngress(options) {
 				};
 				if (isZaloAuthenticationFailure(error)) return {
 					reason: "authentication-failed",
-					message: errorText(error)
+					message: formatErrorMessage(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)}`)
+		onError: (error) => options.runtime.error?.(`zalo ingress drain failed: ${formatErrorMessage(error)}`)
 	});
 	return {
 		accept: async (rawEvent) => {
 			await monitor.admit(rawEvent);
 		},
 		start: monitor.start,
-		stop: async () => {
-			await monitor.stop();
-			await Promise.allSettled(deferredClaims.values());
-		}
+		stop: monitor.stop
 	};
 }
 const zaloWebhookIngressRuntime = { createZaloWebhookIngress };

package/openclaw.plugin.json

@@ -1,5 +1,6 @@
 {
   "id": "zalo",
+  "doctorContract": {},
   "name": "Zalo",
   "description": "OpenClaw Zalo channel plugin for bot and webhook chats.",
   "icon": "https://cdn.simpleicons.org/zalo",
@@ -26,6 +27,9 @@
           "enabled": {
             "type": "boolean"
           },
+          "configWrites": {
+            "type": "boolean"
+          },
           "markdown": {
             "type": "object",
             "properties": {
@@ -71,6 +75,29 @@
                     ],
                     "additionalProperties": false
                   },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "source": {
+                        "type": "string",
+                        "const": "store"
+                      },
+                      "provider": {
+                        "type": "string",
+                        "pattern": "^[a-z][a-z0-9_-]{0,63}$"
+                      },
+                      "id": {
+                        "type": "string",
+                        "pattern": "^[A-Z][A-Z0-9_]{0,127}$"
+                      }
+                    },
+                    "required": [
+                      "source",
+                      "provider",
+                      "id"
+                    ],
+                    "additionalProperties": false
+                  },
                   {
                     "type": "object",
                     "properties": {
@@ -155,6 +182,29 @@
                     ],
                     "additionalProperties": false
                   },
+                  {
+                    "type": "object",
+                    "properties": {
+                      "source": {
+                        "type": "string",
+                        "const": "store"
+                      },
+                      "provider": {
+                        "type": "string",
+                        "pattern": "^[a-z][a-z0-9_-]{0,63}$"
+                      },
+                      "id": {
+                        "type": "string",
+                        "pattern": "^[A-Z][A-Z0-9_]{0,127}$"
+                      }
+                    },
+                    "required": [
+                      "source",
+                      "provider",
+                      "id"
+                    ],
+                    "additionalProperties": false
+                  },
                   {
                     "type": "object",
                     "properties": {
@@ -270,6 +320,9 @@
                 "enabled": {
                   "type": "boolean"
                 },
+                "configWrites": {
+                  "type": "boolean"
+                },
                 "markdown": {
                   "type": "object",
                   "properties": {
@@ -315,6 +368,29 @@
                           ],
                           "additionalProperties": false
                         },
+                        {
+                          "type": "object",
+                          "properties": {
+                            "source": {
+                              "type": "string",
+                              "const": "store"
+                            },
+                            "provider": {
+                              "type": "string",
+                              "pattern": "^[a-z][a-z0-9_-]{0,63}$"
+                            },
+                            "id": {
+                              "type": "string",
+                              "pattern": "^[A-Z][A-Z0-9_]{0,127}$"
+                            }
+                          },
+                          "required": [
+                            "source",
+                            "provider",
+                            "id"
+                          ],
+                          "additionalProperties": false
+                        },
                         {
                           "type": "object",
                           "properties": {
@@ -399,6 +475,29 @@
                           ],
                           "additionalProperties": false
                         },
+                        {
+                          "type": "object",
+                          "properties": {
+                            "source": {
+                              "type": "string",
+                              "const": "store"
+                            },
+                            "provider": {
+                              "type": "string",
+                              "pattern": "^[a-z][a-z0-9_-]{0,63}$"
+                            },
+                            "id": {
+                              "type": "string",
+                              "pattern": "^[A-Z][A-Z0-9_]{0,127}$"
+                            }
+                          },
+                          "required": [
+                            "source",
+                            "provider",
+                            "id"
+                          ],
+                          "additionalProperties": false
+                        },
                         {
                           "type": "object",
                           "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/zalo",
-  "version": "2026.7.2-beta.5",
+  "version": "2026.8.1-beta.2",
   "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.5"
+    "openclaw": ">=2026.8.1-beta.2"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -69,7 +69,10 @@
             "cli": {
               "flags": "--use-env",
               "description": "Use ZALO_BOT_TOKEN"
-            }
+            },
+            "envVars": [
+              "ZALO_BOT_TOKEN"
+            ]
           }
         ]
       }
@@ -80,10 +83,10 @@
       "minHostVersion": ">=2026.4.10"
     },
     "compat": {
-      "pluginApi": ">=2026.7.2-beta.5"
+      "pluginApi": ">=2026.8.1-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.7.2-beta.5"
+      "openclawVersion": "2026.8.1-beta.2"
     },
     "release": {
       "publishToClawHub": true,