@pixelzx/genesis 2026.5.10-6 → 2026.5.14

package/dist/channel-D--fTzTz.js

@@ -0,0 +1,297 @@
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-C3j_3_su.js";
+import { r as createLazyRuntimeModule } from "./lazy-runtime-02MY_g6C.js";
+import { p as formatTrimmedAllowFromEntries, s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-OWFV-v6S.js";
+import { t as buildOutboundBaseSessionKey } from "./base-session-key-CGXu07wB.js";
+import { n as describeAccountSnapshot } from "./account-helpers-ByAGORM5.js";
+import { c as getChatChannelMeta, i as createChatChannelPlugin, r as createChannelPluginBase } from "./core-Bg858J0J.js";
+import "./channel-core-CNZTbaGa.js";
+import "./routing-CXjMOYdN.js";
+import { r as createRestrictSendersChannelSecurity } from "./channel-policy-g_w5qHoF.js";
+import { c as collectStatusIssuesFromLastError, d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-s7kNnR0u.js";
+import { t as sanitizeForPlainText } from "./sanitize-text-RhEEAlk4.js";
+import "./outbound-runtime-CQNa6Zqr.js";
+import { t as chunkTextForOutbound } from "./text-chunking-TasVUNgJ.js";
+import { n as buildDmGroupAccountAllowlistAdapter } from "./allowlist-config-edit-DL2sSGBX.js";
+import { n as buildPassiveProbedChannelStatusSummary } from "./extension-shared-CVYd1ga1.js";
+import { a as listIMessageAccountIds, n as resolveIMessageAttachmentRoots, o as resolveDefaultIMessageAccountId, r as resolveIMessageRemoteAttachmentRoots, s as resolveIMessageAccount } from "./media-contract-CDJ7_GLf.js";
+import { c as looksLikeIMessageExplicitTargetId, d as parseIMessageTarget, i as resolveIMessageConversationIdFromTarget, l as normalizeIMessageHandle, n as matchIMessageAcpConversation, o as inferIMessageTargetChatType, p as normalizeIMessageMessagingTarget, r as normalizeIMessageAcpConversationId } from "./conversation-id-DeXgCGeL.js";
+import { n as createIMessageConversationBindingManager } from "./conversation-bindings-JMOCZXWO.js";
+import { n as resolveIMessageGroupToolPolicy, t as resolveIMessageGroupRequireMention } from "./group-policy-BnsDUY8Q.js";
+import { a as imessageSetupAdapter, n as createIMessageSetupWizardProxy } from "./setup-core-BcPpRVrx.js";
+import { t as IMessageChannelConfigSchema } from "./config-schema-CcUzKDok.js";
+//#region extensions/imessage/src/shared.ts
+const IMESSAGE_CHANNEL = "imessage";
+async function loadIMessageChannelRuntime$1() {
+	return await import("./channel.runtime-BLqQ7wNr.js");
+}
+const imessageSetupWizard = createIMessageSetupWizardProxy(async () => (await loadIMessageChannelRuntime$1()).imessageSetupWizard);
+const imessageConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: IMESSAGE_CHANNEL,
+	listAccountIds: listIMessageAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveIMessageAccount),
+	defaultAccountId: resolveDefaultIMessageAccountId,
+	clearBaseFields: [
+		"cliPath",
+		"dbPath",
+		"service",
+		"region",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => formatTrimmedAllowFromEntries(allowFrom),
+	resolveDefaultTo: (account) => account.config.defaultTo
+});
+const imessageSecurityAdapter = createRestrictSendersChannelSecurity({
+	channelKey: IMESSAGE_CHANNEL,
+	resolveDmPolicy: (account) => account.config.dmPolicy,
+	resolveDmAllowFrom: (account) => account.config.allowFrom,
+	resolveGroupPolicy: (account) => account.config.groupPolicy,
+	surface: "iMessage groups",
+	openScope: "any member",
+	groupPolicyPath: "channels.imessage.groupPolicy",
+	groupAllowFromPath: "channels.imessage.groupAllowFrom",
+	mentionGated: false,
+	policyPathSuffix: "dmPolicy"
+});
+function createIMessagePluginBase(params) {
+	return {
+		...createChannelPluginBase({
+			id: IMESSAGE_CHANNEL,
+			meta: {
+				...getChatChannelMeta(IMESSAGE_CHANNEL),
+				aliases: ["imsg"],
+				showConfigured: false
+			},
+			setupWizard: params.setupWizard,
+			capabilities: {
+				chatTypes: ["direct", "group"],
+				media: true
+			},
+			reload: { configPrefixes: ["channels.imessage"] },
+			configSchema: IMessageChannelConfigSchema,
+			config: {
+				...imessageConfigAdapter,
+				isConfigured: (account) => account.configured,
+				describeAccount: (account) => describeAccountSnapshot({
+					account,
+					configured: account.configured
+				})
+			},
+			security: imessageSecurityAdapter,
+			setup: params.setup
+		}),
+		messaging: {
+			resolveInboundAttachmentRoots: (params) => resolveIMessageAttachmentRoots({
+				accountId: params.accountId,
+				cfg: params.cfg
+			}),
+			resolveRemoteInboundAttachmentRoots: (params) => resolveIMessageRemoteAttachmentRoots({
+				accountId: params.accountId,
+				cfg: params.cfg
+			})
+		}
+	};
+}
+//#endregion
+//#region extensions/imessage/src/status-core.ts
+async function probeIMessageStatusAccount(params) {
+	return await params.probeIMessageAccount({
+		timeoutMs: params.timeoutMs,
+		cliPath: params.account.config.cliPath,
+		dbPath: params.account.config.dbPath
+	});
+}
+//#endregion
+//#region extensions/imessage/src/channel.ts
+const loadIMessageChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-BLqQ7wNr.js"));
+function buildIMessageBaseSessionKey(params) {
+	return buildOutboundBaseSessionKey({
+		...params,
+		channel: "imessage"
+	});
+}
+function resolveIMessageOutboundSessionRoute(params) {
+	const parsed = parseIMessageTarget(params.target);
+	if (parsed.kind === "handle") {
+		const handle = normalizeIMessageHandle(parsed.to);
+		if (!handle) return null;
+		const peer = {
+			kind: "direct",
+			id: handle
+		};
+		const baseSessionKey = buildIMessageBaseSessionKey({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			accountId: params.accountId,
+			peer
+		});
+		return {
+			sessionKey: baseSessionKey,
+			baseSessionKey,
+			peer,
+			chatType: "direct",
+			from: `imessage:${handle}`,
+			to: `imessage:${handle}`
+		};
+	}
+	const peerId = parsed.kind === "chat_id" ? String(parsed.chatId) : parsed.kind === "chat_guid" ? parsed.chatGuid : parsed.chatIdentifier;
+	if (!peerId) return null;
+	const peer = {
+		kind: "group",
+		id: peerId
+	};
+	const baseSessionKey = buildIMessageBaseSessionKey({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		accountId: params.accountId,
+		peer
+	});
+	const toPrefix = parsed.kind === "chat_id" ? "chat_id" : parsed.kind === "chat_guid" ? "chat_guid" : "chat_identifier";
+	return {
+		sessionKey: baseSessionKey,
+		baseSessionKey,
+		peer,
+		chatType: "group",
+		from: `imessage:group:${peerId}`,
+		to: `${toPrefix}:${peerId}`
+	};
+}
+const imessagePlugin = createChatChannelPlugin({
+	base: {
+		...createIMessagePluginBase({
+			setupWizard: imessageSetupWizard,
+			setup: imessageSetupAdapter
+		}),
+		allowlist: buildDmGroupAccountAllowlistAdapter({
+			channelId: "imessage",
+			resolveAccount: resolveIMessageAccount,
+			normalize: ({ values }) => formatTrimmedAllowFromEntries(values),
+			resolveDmAllowFrom: (account) => account.config.allowFrom,
+			resolveGroupAllowFrom: (account) => account.config.groupAllowFrom,
+			resolveDmPolicy: (account) => account.config.dmPolicy,
+			resolveGroupPolicy: (account) => account.config.groupPolicy
+		}),
+		groups: {
+			resolveRequireMention: resolveIMessageGroupRequireMention,
+			resolveToolPolicy: resolveIMessageGroupToolPolicy
+		},
+		doctor: { groupAllowFromFallbackToAllowFrom: false },
+		conversationBindings: {
+			supportsCurrentConversationBinding: true,
+			createManager: ({ cfg, accountId }) => createIMessageConversationBindingManager({
+				cfg,
+				accountId: accountId ?? void 0
+			})
+		},
+		bindings: {
+			compileConfiguredBinding: ({ conversationId }) => normalizeIMessageAcpConversationId(conversationId),
+			matchInboundConversation: ({ compiledBinding, conversationId }) => matchIMessageAcpConversation({
+				bindingConversationId: compiledBinding.conversationId,
+				conversationId
+			}),
+			resolveCommandConversation: ({ originatingTo, commandTo, fallbackTo }) => {
+				const conversationId = resolveIMessageConversationIdFromTarget(originatingTo ?? "") ?? resolveIMessageConversationIdFromTarget(commandTo ?? "") ?? resolveIMessageConversationIdFromTarget(fallbackTo ?? "");
+				return conversationId ? { conversationId } : null;
+			}
+		},
+		messaging: {
+			normalizeTarget: normalizeIMessageMessagingTarget,
+			inferTargetChatType: ({ to }) => inferIMessageTargetChatType(to),
+			resolveOutboundSessionRoute: (params) => resolveIMessageOutboundSessionRoute(params),
+			targetResolver: {
+				looksLikeId: looksLikeIMessageExplicitTargetId,
+				hint: "<handle|chat_id:ID>",
+				resolveTarget: async ({ normalized }) => {
+					const to = normalized?.trim();
+					if (!to) return null;
+					const chatType = inferIMessageTargetChatType(to);
+					if (!chatType) return null;
+					return {
+						to,
+						kind: chatType === "direct" ? "user" : "group",
+						source: "normalized"
+					};
+				}
+			}
+		},
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID, {
+				cliPath: null,
+				dbPath: null
+			}),
+			collectStatusIssues: (accounts) => collectStatusIssuesFromLastError("imessage", accounts),
+			buildChannelSummary: ({ snapshot }) => buildPassiveProbedChannelStatusSummary(snapshot, {
+				cliPath: snapshot.cliPath ?? null,
+				dbPath: snapshot.dbPath ?? null
+			}),
+			probeAccount: async ({ account, timeoutMs }) => await probeIMessageStatusAccount({
+				account,
+				timeoutMs,
+				probeIMessageAccount: async (params) => await (await loadIMessageChannelRuntime()).probeIMessageAccount(params)
+			}),
+			resolveAccountSnapshot: ({ account, runtime }) => ({
+				accountId: account.accountId,
+				name: account.name,
+				enabled: account.enabled,
+				configured: account.configured,
+				extra: {
+					cliPath: runtime?.cliPath ?? account.config.cliPath ?? null,
+					dbPath: runtime?.dbPath ?? account.config.dbPath ?? null
+				}
+			}),
+			resolveAccountState: ({ enabled }) => enabled ? "enabled" : "disabled"
+		}),
+		gateway: { startAccount: async (ctx) => {
+			const conversationBindings = createIMessageConversationBindingManager({
+				cfg: ctx.cfg,
+				accountId: ctx.accountId
+			});
+			try {
+				return await (await loadIMessageChannelRuntime()).startIMessageGatewayAccount(ctx);
+			} finally {
+				conversationBindings.stop();
+			}
+		} }
+	},
+	pairing: { text: {
+		idLabel: "imessageSenderId",
+		message: "Genesis: your access has been approved.",
+		notify: async ({ id, cfg }) => await (await loadIMessageChannelRuntime()).notifyIMessageApproval({
+			id,
+			cfg
+		})
+	} },
+	security: imessageSecurityAdapter,
+	outbound: {
+		base: {
+			deliveryMode: "direct",
+			chunker: chunkTextForOutbound,
+			chunkerMode: "text",
+			textChunkLimit: 4e3,
+			sanitizeText: ({ text }) => sanitizeForPlainText(text)
+		},
+		attachedResults: {
+			channel: "imessage",
+			sendText: async ({ cfg, to, text, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
+				cfg,
+				to,
+				text,
+				accountId: accountId ?? void 0,
+				deps,
+				replyToId: replyToId ?? void 0
+			}),
+			sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, deps, replyToId }) => await (await loadIMessageChannelRuntime()).sendIMessageOutbound({
+				cfg,
+				to,
+				text,
+				mediaUrl,
+				mediaLocalRoots,
+				accountId: accountId ?? void 0,
+				deps,
+				replyToId: replyToId ?? void 0
+			})
+		}
+	}
+});
+//#endregion
+export { createIMessagePluginBase as n, imessageSetupWizard as r, imessagePlugin as t };

package/dist/channel-D6MPpTUg.js

@@ -0,0 +1,350 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-C1IzJjqi.js";
+import { h as MarkdownConfigSchema, l as GroupPolicySchema, o as DmPolicySchema } from "./zod-schema.core--iz7S8Y4.js";
+import { n as buildCatchallMultiAccountChannelSchema, r as buildChannelConfigSchema, t as AllowFromListSchema } from "./config-schema-BEt8F1Tk.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-C3j_3_su.js";
+import { b as sendPayloadWithChunkedTextAndMedia, l as isNumericTargetId } from "./reply-payload-ChFsXpe2.js";
+import { i as createLazyRuntimeNamedExport, r as createLazyRuntimeModule } from "./lazy-runtime-02MY_g6C.js";
+import { g as readStringParam, l as jsonResult } from "./common-CxZxlH5x.js";
+import { l as createScopedDmSecurityResolver, m as mapAllowFromEntries, s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-OWFV-v6S.js";
+import "./text-runtime-COlr0gTx.js";
+import { r as describeWebhookAccountSnapshot } from "./account-helpers-ByAGORM5.js";
+import { n as createStaticReplyToModeResolver } from "./threading-helpers-C5mVnLhV.js";
+import { d as stripTargetKindPrefix, i as createChatChannelPlugin, t as buildChannelOutboundSessionRoute, u as stripChannelTargetPrefix } from "./core-Bg858J0J.js";
+import "./channel-core-CNZTbaGa.js";
+import { r as buildSecretInputSchema } from "./secret-input-DF9sCi1n.js";
+import { t as formatAllowFromLowercase } from "./allow-from-Bygsv_2E.js";
+import "./channel-config-schema-Ck6O6RSb.js";
+import { S as createOpenProviderGroupPolicyWarningCollector, o as buildOpenGroupPolicyRestrictSendersWarning, s as buildOpenGroupPolicyWarning } from "./channel-policy-g_w5qHoF.js";
+import { t as createChannelDirectoryAdapter } from "./directory-runtime-DI4YPEKY.js";
+import { p as listResolvedDirectoryUserEntriesFromAllowFrom } from "./directory-config-helpers-CT1Bqvx2.js";
+import { d as createDefaultChannelRuntimeState, o as buildTokenChannelStatusSummary, u as createComputedAccountStatusAdapter } from "./status-helpers-s7kNnR0u.js";
+import { t as extractToolSend } from "./tool-send-C5uH9tuB.js";
+import { t as resolveApprovalApprovers } from "./approval-approvers-D8ltnIzX.js";
+import { t as createResolvedApproverActionAuthAdapter } from "./approval-auth-helpers-BpDabghY.js";
+import "./conversation-runtime-d5Fy5tiD.js";
+import { t as chunkTextForOutbound } from "./text-chunking-TasVUNgJ.js";
+import { a as coerceStatusIssueAccountId, d as readStatusIssueFields } from "./extension-shared-CVYd1ga1.js";
+import "./channel-actions-CDzrYUpG.js";
+import { a as createEmptyChannelResult, o as createRawChannelSendResultAdapter } from "./channel-send-result-Nse0U3Cg.js";
+import "./channel-status-BGa1Zh6l.js";
+import { t as zod_exports } from "./zod-CkmW0nZz.js";
+import { i as resolveZaloAccount, n as listZaloAccountIds, r as resolveDefaultZaloAccountId, t as listEnabledZaloAccounts } from "./accounts-CmWsTjc0.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-55w2wUZb.js";
+import { r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-BSBr6Pj_.js";
+//#region extensions/zalo/src/actions.ts
+const loadZaloActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-D2P74T6w.js"), "zaloActionsRuntime");
+const providerId = "zalo";
+function listEnabledAccounts(cfg, accountId) {
+	return (accountId ? [resolveZaloAccount({
+		cfg,
+		accountId
+	})] : listEnabledZaloAccounts(cfg)).filter((account) => account.enabled && account.tokenSource !== "none");
+}
+const zaloMessageActions = {
+	describeMessageTool: ({ cfg, accountId }) => {
+		if (listEnabledAccounts(cfg, accountId).length === 0) return null;
+		const actions = new Set(["send"]);
+		return {
+			actions: Array.from(actions),
+			capabilities: []
+		};
+	},
+	extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+	handleAction: async ({ action, params, cfg, accountId }) => {
+		if (action === "send") {
+			const to = readStringParam(params, "to", { required: true });
+			const content = readStringParam(params, "message", {
+				required: true,
+				allowEmpty: true
+			});
+			const mediaUrl = readStringParam(params, "media", { trim: false });
+			const { sendMessageZalo } = await loadZaloActionsRuntime();
+			const result = await sendMessageZalo(to ?? "", content ?? "", {
+				accountId: accountId ?? void 0,
+				mediaUrl: mediaUrl ?? void 0,
+				cfg
+			});
+			if (!result.ok) return jsonResult({
+				ok: false,
+				error: result.error ?? "Failed to send Zalo message"
+			});
+			return jsonResult({
+				ok: true,
+				to,
+				messageId: result.messageId
+			});
+		}
+		throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+	}
+};
+//#endregion
+//#region extensions/zalo/src/approval-auth.ts
+function normalizeZaloApproverId(value) {
+	const normalized = String(value).trim().replace(/^(zalo|zl):/i, "").trim();
+	return /^\d+$/.test(normalized) ? normalized : void 0;
+}
+const zaloApprovalAuth = createResolvedApproverActionAuthAdapter({
+	channelLabel: "Zalo",
+	resolveApprovers: ({ cfg, accountId }) => {
+		const account = resolveZaloAccount({
+			cfg,
+			accountId
+		}).config;
+		return resolveApprovalApprovers({
+			allowFrom: account.allowFrom,
+			normalizeApprover: normalizeZaloApproverId
+		});
+	},
+	normalizeSenderId: (value) => normalizeZaloApproverId(value)
+});
+const ZaloConfigSchema = buildCatchallMultiAccountChannelSchema(zod_exports.z.object({
+	name: zod_exports.z.string().optional(),
+	enabled: zod_exports.z.boolean().optional(),
+	markdown: MarkdownConfigSchema,
+	botToken: buildSecretInputSchema().optional(),
+	tokenFile: zod_exports.z.string().optional(),
+	webhookUrl: zod_exports.z.string().optional(),
+	webhookSecret: buildSecretInputSchema().optional(),
+	webhookPath: zod_exports.z.string().optional(),
+	dmPolicy: DmPolicySchema.optional(),
+	allowFrom: AllowFromListSchema,
+	groupPolicy: GroupPolicySchema.optional(),
+	groupAllowFrom: AllowFromListSchema,
+	mediaMaxMb: zod_exports.z.number().optional(),
+	proxy: zod_exports.z.string().optional(),
+	responsePrefix: zod_exports.z.string().optional()
+}));
+//#endregion
+//#region extensions/zalo/src/session-route.ts
+function resolveZaloOutboundSessionRoute(params) {
+	const trimmed = stripChannelTargetPrefix(params.target, "zalo", "zl");
+	if (!trimmed) return null;
+	const isGroup = normalizeLowercaseStringOrEmpty(trimmed).startsWith("group:");
+	const peerId = stripTargetKindPrefix(trimmed);
+	if (!peerId) return null;
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "zalo",
+		accountId: params.accountId,
+		peer: {
+			kind: isGroup ? "group" : "direct",
+			id: peerId
+		},
+		chatType: isGroup ? "group" : "direct",
+		from: isGroup ? `zalo:group:${peerId}` : `zalo:${peerId}`,
+		to: `zalo:${peerId}`
+	});
+}
+//#endregion
+//#region extensions/zalo/src/status-issues.ts
+const ZALO_STATUS_FIELDS = [
+	"accountId",
+	"enabled",
+	"configured",
+	"dmPolicy"
+];
+function collectZaloStatusIssues(accounts) {
+	const issues = [];
+	for (const entry of accounts) {
+		const account = readStatusIssueFields(entry, ZALO_STATUS_FIELDS);
+		if (!account) continue;
+		const accountId = coerceStatusIssueAccountId(account.accountId) ?? "default";
+		const enabled = account.enabled !== false;
+		const configured = account.configured === true;
+		if (!enabled || !configured) continue;
+		if (account.dmPolicy === "open") issues.push({
+			channel: "zalo",
+			accountId,
+			kind: "config",
+			message: "Zalo dmPolicy is \"open\", allowing any user to message the bot without pairing.",
+			fix: "Set channels.zalo.dmPolicy to \"pairing\" or \"allowlist\" to restrict access."
+		});
+	}
+	return issues;
+}
+//#endregion
+//#region extensions/zalo/src/channel.ts
+const meta = {
+	id: "zalo",
+	label: "Zalo",
+	selectionLabel: "Zalo (Bot API)",
+	docsPath: "/channels/zalo",
+	docsLabel: "zalo",
+	blurb: "Vietnam-focused messaging platform with Bot API.",
+	aliases: ["zl"],
+	order: 80,
+	quickstartAllowFrom: true
+};
+function normalizeZaloMessagingTarget(raw) {
+	const trimmed = raw?.trim();
+	if (!trimmed) return;
+	return trimmed.replace(/^(zalo|zl):/i, "").trim();
+}
+const loadZaloChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-DVck4iX6.js"));
+const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-DWBtQcYb.js")).zaloSetupWizard);
+const zaloTextChunkLimit = 2e3;
+const zaloRawSendResultAdapter = createRawChannelSendResultAdapter({
+	channel: "zalo",
+	sendText: async ({ to, text, accountId, cfg }) => await (await loadZaloChannelRuntime()).sendZaloText({
+		to,
+		text,
+		accountId: accountId ?? void 0,
+		cfg
+	}),
+	sendMedia: async ({ to, text, mediaUrl, accountId, cfg }) => await (await loadZaloChannelRuntime()).sendZaloText({
+		to,
+		text,
+		accountId: accountId ?? void 0,
+		mediaUrl,
+		cfg
+	})
+});
+const zaloConfigAdapter = createScopedChannelConfigAdapter({
+	sectionKey: "zalo",
+	listAccountIds: listZaloAccountIds,
+	resolveAccount: adaptScopedAccountAccessor(resolveZaloAccount),
+	defaultAccountId: resolveDefaultZaloAccountId,
+	clearBaseFields: [
+		"botToken",
+		"tokenFile",
+		"name"
+	],
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({
+		allowFrom,
+		stripPrefixRe: /^(zalo|zl):/i
+	})
+});
+const resolveZaloDmPolicy = createScopedDmSecurityResolver({
+	channelKey: "zalo",
+	resolvePolicy: (account) => account.config.dmPolicy,
+	resolveAllowFrom: (account) => account.config.allowFrom,
+	policyPathSuffix: "dmPolicy",
+	normalizeEntry: (raw) => raw.trim().replace(/^(zalo|zl):/i, "")
+});
+const collectZaloSecurityWarnings = createOpenProviderGroupPolicyWarningCollector({
+	providerConfigPresent: (cfg) => cfg.channels?.zalo !== void 0,
+	resolveGroupPolicy: ({ account }) => account.config.groupPolicy,
+	collect: ({ account, groupPolicy }) => {
+		if (groupPolicy !== "open") return [];
+		const explicitGroupAllowFrom = mapAllowFromEntries(account.config.groupAllowFrom);
+		const dmAllowFrom = mapAllowFromEntries(account.config.allowFrom);
+		if ((explicitGroupAllowFrom.length > 0 ? explicitGroupAllowFrom : dmAllowFrom).length > 0) return [buildOpenGroupPolicyRestrictSendersWarning({
+			surface: "Zalo groups",
+			openScope: "any member",
+			groupPolicyPath: "channels.zalo.groupPolicy",
+			groupAllowFromPath: "channels.zalo.groupAllowFrom"
+		})];
+		return [buildOpenGroupPolicyWarning({
+			surface: "Zalo groups",
+			openBehavior: "with no groupAllowFrom/allowFrom allowlist; any member can trigger (mention-gated)",
+			remediation: "Set channels.zalo.groupPolicy=\"allowlist\" + channels.zalo.groupAllowFrom"
+		})];
+	}
+});
+const zaloPlugin = createChatChannelPlugin({
+	base: {
+		id: "zalo",
+		meta,
+		setup: zaloSetupAdapter,
+		setupWizard: zaloSetupWizard,
+		capabilities: {
+			chatTypes: ["direct", "group"],
+			media: true,
+			reactions: false,
+			threads: false,
+			polls: false,
+			nativeCommands: false,
+			blockStreaming: true
+		},
+		reload: { configPrefixes: ["channels.zalo"] },
+		configSchema: buildChannelConfigSchema(ZaloConfigSchema),
+		config: {
+			...zaloConfigAdapter,
+			isConfigured: (account) => Boolean(account.token?.trim()),
+			describeAccount: (account) => describeWebhookAccountSnapshot({
+				account,
+				configured: Boolean(account.token?.trim()),
+				mode: account.config.webhookUrl ? "webhook" : "polling",
+				extra: { tokenSource: account.tokenSource }
+			})
+		},
+		approvalCapability: zaloApprovalAuth,
+		secrets: {
+			secretTargetRegistryEntries,
+			collectRuntimeConfigAssignments
+		},
+		groups: { resolveRequireMention: () => true },
+		actions: zaloMessageActions,
+		messaging: {
+			normalizeTarget: normalizeZaloMessagingTarget,
+			resolveOutboundSessionRoute: (params) => resolveZaloOutboundSessionRoute(params),
+			targetResolver: {
+				looksLikeId: isNumericTargetId,
+				hint: "<chatId>"
+			}
+		},
+		directory: createChannelDirectoryAdapter({
+			listPeers: async (params) => listResolvedDirectoryUserEntriesFromAllowFrom({
+				...params,
+				resolveAccount: adaptScopedAccountAccessor(resolveZaloAccount),
+				resolveAllowFrom: (account) => account.config.allowFrom,
+				normalizeId: (entry) => entry.trim().replace(/^(zalo|zl):/i, "")
+			}),
+			listGroups: async () => []
+		}),
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: collectZaloStatusIssues,
+			buildChannelSummary: ({ snapshot }) => buildTokenChannelStatusSummary(snapshot),
+			probeAccount: async ({ account, timeoutMs }) => await (await loadZaloChannelRuntime()).probeZaloAccount({
+				account,
+				timeoutMs
+			}),
+			resolveAccountSnapshot: ({ account }) => {
+				const configured = Boolean(account.token?.trim());
+				return {
+					accountId: account.accountId,
+					name: account.name,
+					enabled: account.enabled,
+					configured,
+					extra: {
+						tokenSource: account.tokenSource,
+						mode: account.config.webhookUrl ? "webhook" : "polling",
+						dmPolicy: account.config.dmPolicy ?? "pairing"
+					}
+				};
+			}
+		}),
+		gateway: { startAccount: async (ctx) => await (await loadZaloChannelRuntime()).startZaloGatewayAccount(ctx) }
+	},
+	security: {
+		resolveDmPolicy: resolveZaloDmPolicy,
+		collectWarnings: collectZaloSecurityWarnings
+	},
+	pairing: { text: {
+		idLabel: "zaloUserId",
+		message: "Your pairing request has been approved.",
+		normalizeAllowEntry: (entry) => entry.trim().replace(/^(zalo|zl):/i, ""),
+		notify: async (params) => await (await loadZaloChannelRuntime()).notifyZaloPairingApproval(params)
+	} },
+	threading: { resolveReplyToMode: createStaticReplyToModeResolver("off") },
+	outbound: {
+		deliveryMode: "direct",
+		chunker: chunkTextForOutbound,
+		chunkerMode: "text",
+		textChunkLimit: zaloTextChunkLimit,
+		sendPayload: async (ctx) => await sendPayloadWithChunkedTextAndMedia({
+			ctx,
+			textChunkLimit: zaloTextChunkLimit,
+			chunker: chunkTextForOutbound,
+			sendText: (nextCtx) => zaloRawSendResultAdapter.sendText(nextCtx),
+			sendMedia: (nextCtx) => zaloRawSendResultAdapter.sendMedia(nextCtx),
+			emptyResult: createEmptyChannelResult("zalo")
+		}),
+		...zaloRawSendResultAdapter
+	}
+});
+//#endregion
+export { zaloPlugin as t };