@gaodefa/daocore 2026.5.34 → 2026.5.36

package/dist/channel-DI30oIzM.js

@@ -0,0 +1,238 @@
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { At as boolean, Et as array, Nn as record, Rn as string, Tn as object, yt as _enum } from "./schemas-Del5uzR8.js";
+import { r as buildChannelConfigSchema } from "./config-schema-CpJ4LFf2.js";
+import { r as createLazyRuntimeModule } from "./lazy-runtime-D-7_JraP.js";
+import { i as createHybridChannelConfigAdapter } from "./channel-config-helpers-CQb9YOAn.js";
+import { n as describeAccountSnapshot } from "./account-helpers-BEXOONiv.js";
+import { i as createChatChannelPlugin, t as buildChannelOutboundSessionRoute } from "./core-DDHeEXv5.js";
+import "./channel-core-Cip0DXqW.js";
+import "./channel-config-schema-vbY58Vzl.js";
+import { n as createRuntimeOutboundDelegates } from "./runtime-forwarders-CJHIfxll.js";
+import "./outbound-runtime-BWFKdtGY.js";
+import { d as createDefaultChannelRuntimeState, u as createComputedAccountStatusAdapter } from "./status-helpers-nyf_mfYa.js";
+import { k as createChannelMessageAdapterFromOutbound } from "./channel-message-YAmKOwAT.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-ZWsP0AGC.js";
+import { a as tlonSetupAdapter, d as formatTargetHint, f as normalizeShip, h as resolveTlonOutboundTarget, l as listTlonAccountIds, m as parseTlonTarget, n as createTlonSetupWizardBase, u as resolveTlonAccount } from "./setup-core-BoeMMX3L.js";
+//#region extensions/tlon/src/config-schema.ts
+const ShipSchema = string().min(1);
+const ChannelNestSchema = string().min(1);
+const TlonChannelRuleSchema = object({
+	mode: _enum(["restricted", "open"]).optional(),
+	allowedShips: array(ShipSchema).optional()
+});
+const TlonAuthorizationSchema = object({ channelRules: record(string(), TlonChannelRuleSchema).optional() });
+const TlonNetworkSchema = object({ dangerouslyAllowPrivateNetwork: boolean().optional() }).strict().optional();
+const tlonCommonConfigFields = {
+	name: string().optional(),
+	enabled: boolean().optional(),
+	ship: ShipSchema.optional(),
+	url: string().optional(),
+	code: string().optional(),
+	network: TlonNetworkSchema,
+	groupChannels: array(ChannelNestSchema).optional(),
+	dmAllowlist: array(ShipSchema).optional(),
+	groupInviteAllowlist: array(ShipSchema).optional(),
+	autoDiscoverChannels: boolean().optional(),
+	showModelSignature: boolean().optional(),
+	responsePrefix: string().optional(),
+	autoAcceptDmInvites: boolean().optional(),
+	autoAcceptGroupInvites: boolean().optional(),
+	ownerShip: ShipSchema.optional()
+};
+const TlonAccountSchema = object({ ...tlonCommonConfigFields });
+const tlonChannelConfigSchema = buildChannelConfigSchema(object({
+	...tlonCommonConfigFields,
+	authorization: TlonAuthorizationSchema.optional(),
+	defaultAuthorizedShips: array(ShipSchema).optional(),
+	accounts: record(string(), TlonAccountSchema).optional()
+}));
+//#endregion
+//#region extensions/tlon/src/doctor.ts
+const tlonDoctor = {
+	legacyConfigRules,
+	normalizeCompatibilityConfig
+};
+//#endregion
+//#region extensions/tlon/src/session-route.ts
+function resolveTlonOutboundSessionRoute(params) {
+	const parsed = parseTlonTarget(params.target);
+	if (!parsed) return null;
+	if (parsed.kind === "group") return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "tlon",
+		accountId: params.accountId,
+		peer: {
+			kind: "group",
+			id: parsed.nest
+		},
+		chatType: "group",
+		from: `tlon:group:${parsed.nest}`,
+		to: `tlon:${parsed.nest}`
+	});
+	return buildChannelOutboundSessionRoute({
+		cfg: params.cfg,
+		agentId: params.agentId,
+		channel: "tlon",
+		accountId: params.accountId,
+		peer: {
+			kind: "direct",
+			id: parsed.ship
+		},
+		chatType: "direct",
+		from: `tlon:${parsed.ship}`,
+		to: `tlon:${parsed.ship}`
+	});
+}
+//#endregion
+//#region extensions/tlon/src/channel.ts
+const TLON_CHANNEL_ID = "tlon";
+const loadTlonChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime-DfQ7lbcl.js"));
+const tlonSetupWizardProxy = createTlonSetupWizardBase({
+	resolveConfigured: async ({ cfg, accountId }) => await (await loadTlonChannelRuntime()).tlonSetupWizard.status.resolveConfigured({
+		cfg,
+		accountId
+	}),
+	resolveStatusLines: async ({ cfg, accountId, configured }) => await (await loadTlonChannelRuntime()).tlonSetupWizard.status.resolveStatusLines?.({
+		cfg,
+		accountId,
+		configured
+	}) ?? [],
+	finalize: async (params) => await (await loadTlonChannelRuntime()).tlonSetupWizard.finalize(params)
+});
+const tlonConfigAdapter = createHybridChannelConfigAdapter({
+	sectionKey: TLON_CHANNEL_ID,
+	listAccountIds: listTlonAccountIds,
+	resolveAccount: resolveTlonAccount,
+	defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+	clearBaseFields: [
+		"ship",
+		"code",
+		"url",
+		"name"
+	],
+	preserveSectionOnDefaultDelete: true,
+	resolveAllowFrom: (account) => account.dmAllowlist,
+	formatAllowFrom: (allowFrom) => allowFrom.map((entry) => normalizeShip(String(entry))).filter(Boolean)
+});
+const tlonChannelOutbound = {
+	deliveryMode: "direct",
+	textChunkLimit: 1e4,
+	resolveTarget: ({ to }) => resolveTlonOutboundTarget(to),
+	deliveryCapabilities: { durableFinal: {
+		text: true,
+		media: true,
+		replyTo: true,
+		thread: true,
+		messageSendingHooks: true
+	} },
+	...createRuntimeOutboundDelegates({
+		getRuntime: loadTlonChannelRuntime,
+		sendText: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendText },
+		sendMedia: { resolve: (runtime) => runtime.tlonRuntimeOutbound.sendMedia }
+	})
+};
+const tlonMessageAdapter = createChannelMessageAdapterFromOutbound({
+	id: TLON_CHANNEL_ID,
+	outbound: tlonChannelOutbound
+});
+const tlonPlugin = createChatChannelPlugin({
+	base: {
+		id: TLON_CHANNEL_ID,
+		meta: {
+			id: TLON_CHANNEL_ID,
+			label: "Tlon",
+			selectionLabel: "Tlon (Urbit)",
+			docsPath: "/channels/tlon",
+			docsLabel: "tlon",
+			blurb: "Decentralized messaging on Urbit",
+			aliases: ["urbit"],
+			order: 90
+		},
+		capabilities: {
+			chatTypes: [
+				"direct",
+				"group",
+				"thread"
+			],
+			media: true,
+			reply: true,
+			threads: true
+		},
+		setup: tlonSetupAdapter,
+		setupWizard: tlonSetupWizardProxy,
+		reload: { configPrefixes: ["channels.tlon"] },
+		configSchema: tlonChannelConfigSchema,
+		config: {
+			...tlonConfigAdapter,
+			isConfigured: (account) => account.configured,
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: account.configured,
+				extra: {
+					ship: account.ship,
+					url: account.url
+				}
+			})
+		},
+		doctor: tlonDoctor,
+		messaging: {
+			targetPrefixes: ["tlon"],
+			normalizeTarget: (target) => {
+				const parsed = parseTlonTarget(target);
+				if (!parsed) return target.trim();
+				if (parsed.kind === "dm") return parsed.ship;
+				return parsed.nest;
+			},
+			targetResolver: {
+				looksLikeId: (target) => Boolean(parseTlonTarget(target)),
+				hint: formatTargetHint()
+			},
+			resolveOutboundSessionRoute: (params) => resolveTlonOutboundSessionRoute(params)
+		},
+		message: tlonMessageAdapter,
+		status: createComputedAccountStatusAdapter({
+			defaultRuntime: createDefaultChannelRuntimeState(DEFAULT_ACCOUNT_ID),
+			collectStatusIssues: (accounts) => {
+				return accounts.flatMap((account) => {
+					if (!account.configured) return [{
+						channel: TLON_CHANNEL_ID,
+						accountId: account.accountId,
+						kind: "config",
+						message: "Account not configured (missing ship, code, or url)"
+					}];
+					return [];
+				});
+			},
+			buildChannelSummary: ({ snapshot }) => {
+				const s = snapshot;
+				return {
+					configured: s.configured ?? false,
+					ship: s.ship ?? null,
+					url: s.url ?? null
+				};
+			},
+			probeAccount: async ({ account }) => {
+				if (!account.configured || !account.ship || !account.url || !account.code) return {
+					ok: false,
+					error: "Not configured"
+				};
+				return await (await loadTlonChannelRuntime()).probeTlonAccount(account);
+			},
+			resolveAccountSnapshot: ({ account }) => ({
+				accountId: account.accountId,
+				name: account.name ?? void 0,
+				enabled: account.enabled,
+				configured: account.configured,
+				extra: {
+					ship: account.ship,
+					url: account.url
+				}
+			})
+		}),
+		gateway: { startAccount: async (ctx) => await (await loadTlonChannelRuntime()).startTlonGatewayAccount(ctx) }
+	},
+	outbound: tlonChannelOutbound
+});
+//#endregion
+export { tlonPlugin as t };

package/dist/channel-Dwmhp2QK.js

@@ -0,0 +1,376 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import { t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { At as boolean, Rn as string, Tn as object, wn as number } from "./schemas-Del5uzR8.js";
+import { h as MarkdownConfigSchema, l as GroupPolicySchema, o as DmPolicySchema } from "./zod-schema.core-D3MmpZyV.js";
+import { n as buildCatchallMultiAccountChannelSchema, r as buildChannelConfigSchema, t as AllowFromListSchema } from "./config-schema-CpJ4LFf2.js";
+import { b as sendPayloadWithChunkedTextAndMedia, l as isNumericTargetId } from "./reply-payload-DMPQsrQC.js";
+import { i as createLazyRuntimeNamedExport, r as createLazyRuntimeModule } from "./lazy-runtime-D-7_JraP.js";
+import { c as jsonResult, g as readStringParam } from "./common-vJyw6dD-.js";
+import { l as createScopedDmSecurityResolver, m as mapAllowFromEntries, s as createScopedChannelConfigAdapter, t as adaptScopedAccountAccessor } from "./channel-config-helpers-CQb9YOAn.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { r as describeWebhookAccountSnapshot } from "./account-helpers-BEXOONiv.js";
+import { n as createStaticReplyToModeResolver } from "./threading-helpers-JSVFlQzA.js";
+import { d as stripTargetKindPrefix, i as createChatChannelPlugin, t as buildChannelOutboundSessionRoute, u as stripChannelTargetPrefix } from "./core-DDHeEXv5.js";
+import "./channel-core-Cip0DXqW.js";
+import { r as buildSecretInputSchema } from "./secret-input-s8BgZnEq.js";
+import { t as formatAllowFromLowercase } from "./allow-from-BsbZfqm-.js";
+import "./channel-config-schema-vbY58Vzl.js";
+import { C as createOpenProviderGroupPolicyWarningCollector, o as buildOpenGroupPolicyRestrictSendersWarning, s as buildOpenGroupPolicyWarning } from "./channel-policy-Be-Ujzjr.js";
+import { t as createChannelDirectoryAdapter } from "./directory-runtime-C8foW0XO.js";
+import { p as listResolvedDirectoryUserEntriesFromAllowFrom } from "./directory-config-helpers-DoW5C2Kp.js";
+import { t as resolveApprovalApprovers } from "./approval-approvers-BaAy3FfF.js";
+import { t as createResolvedApproverActionAuthAdapter } from "./approval-auth-helpers-DSaKGCWn.js";
+import "./conversation-runtime-CAGsRmgG.js";
+import { t as chunkTextForOutbound } from "./text-chunking-ObhJDe8L.js";
+import { d as createDefaultChannelRuntimeState, o as buildTokenChannelStatusSummary, u as createComputedAccountStatusAdapter } from "./status-helpers-nyf_mfYa.js";
+import "./channel-status-1yY-1IXP.js";
+import { a as coerceStatusIssueAccountId, d as readStatusIssueFields } from "./extension-shared-D6I0yOLZ.js";
+import "./channel-actions-BEsMIO8Q.js";
+import { r as defineChannelMessageAdapter } from "./channel-message-YAmKOwAT.js";
+import { a as createEmptyChannelResult, o as createRawChannelSendResultAdapter } from "./channel-send-result-swFdRKhg.js";
+import { t as extractToolSend } from "./tool-send-CH_ybyG1.js";
+import { i as resolveZaloAccount, n as listZaloAccountIds, r as resolveDefaultZaloAccountId, t as listEnabledZaloAccounts } from "./accounts-C6REvXTb.js";
+import { n as collectRuntimeConfigAssignments, r as secretTargetRegistryEntries } from "./secret-contract-qhJk3C0x.js";
+import { r as zaloSetupAdapter, t as createZaloSetupWizardProxy } from "./setup-core-CinEapxM.js";
+//#region extensions/zalo/src/actions.ts
+const loadZaloActionsRuntime = createLazyRuntimeNamedExport(() => import("./actions.runtime-f4FlBapO.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(object({
+	name: string().optional(),
+	enabled: boolean().optional(),
+	markdown: MarkdownConfigSchema,
+	botToken: buildSecretInputSchema().optional(),
+	tokenFile: string().optional(),
+	webhookUrl: string().optional(),
+	webhookSecret: buildSecretInputSchema().optional(),
+	webhookPath: string().optional(),
+	dmPolicy: DmPolicySchema.optional(),
+	allowFrom: AllowFromListSchema,
+	groupPolicy: GroupPolicySchema.optional(),
+	groupAllowFrom: AllowFromListSchema,
+	mediaMaxMb: number().optional(),
+	proxy: string().optional(),
+	responsePrefix: 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-BhiiHau6.js"));
+const zaloSetupWizard = createZaloSetupWizardProxy(async () => (await import("./setup-surface-BCtf5vsv.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 zaloMessageAdapter = defineChannelMessageAdapter({
+	id: "zalo",
+	durableFinal: { capabilities: {
+		text: true,
+		media: true,
+		messageSendingHooks: true
+	} },
+	send: {
+		text: async ({ to, text, accountId, cfg }) => await (await loadZaloChannelRuntime()).sendZaloText({
+			to,
+			text,
+			accountId: accountId ?? void 0,
+			cfg
+		}),
+		media: 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: {
+			targetPrefixes: ["zalo", "zl"],
+			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) },
+		message: zaloMessageAdapter
+	},
+	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 };