openclaw 2026.5.19-beta.2 → 2026.5.19

package/dist/abort-JN5J8_wx.js

@@ -0,0 +1,221 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-LndEvhRk.js";
+import { i as formatErrorMessage } from "./errors-ixwfrboQ.js";
+import { _ as resolveSessionAgentId } from "./agent-scope-DMMelGwC.js";
+import { c as parseAgentSessionKey } from "./session-key-utils-CJRKuBJA.js";
+import { r as logVerbose } from "./globals-BJh4IgxP.js";
+import { u as resolveStorePath } from "./paths-RbVDOqFp.js";
+import { A as resolveSessionStoreEntry, t as loadSessionStore } from "./store-load-BzczsLeI.js";
+import { s as updateSessionStore } from "./store-C86lM9dg.js";
+import "./sessions-DyRU6Npc.js";
+import { t as getAcpSessionManager } from "./manager-BhNtPBCf.js";
+import { f as replyRunRegistry } from "./reply-run-registry-BICdh-2F.js";
+import { n as abortEmbeddedPiRun, p as resolveActiveEmbeddedRunSessionId } from "./runs-D-B-YVbL.js";
+import { c as resolveMainSessionAlias, s as resolveInternalSessionKey } from "./sessions-helpers-C10nHz4U.js";
+import { a as clearSessionQueues } from "./queue-Dlf115nQ.js";
+import { f as markSubagentRunTerminated, o as getLatestSubagentRunByChildSessionKey, u as listSubagentRunsForController } from "./subagent-registry-C04LPv4J.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-BbDYhEM_.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-CEoKwf9I.js";
+import { t as resolveCommandAuthorization } from "./command-auth-Dxm0fY8L.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-GE1AVWsx.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	resolveActiveEmbeddedRunSessionId,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+function abortSessionRunTarget(params) {
+	const sessionIds = /* @__PURE__ */ new Set();
+	const key = normalizeOptionalString(params.key);
+	if (key) {
+		const activeSessionId = abortDeps.resolveActiveEmbeddedRunSessionId(key);
+		if (activeSessionId) sessionIds.add(activeSessionId);
+	}
+	const explicitSessionId = normalizeOptionalString(params.sessionId);
+	if (explicitSessionId) sessionIds.add(explicitSessionId);
+	let aborted = key ? replyRunRegistry.abort(key) : false;
+	for (const sessionId of sessionIds) aborted = abortDeps.abortEmbeddedPiRun(sessionId) || aborted;
+	return aborted;
+}
+function formatAbortReplyText(stoppedSubagents) {
+	if (typeof stoppedSubagents !== "number" || stoppedSubagents <= 0) return "⚙️ Agent was aborted.";
+	return `⚙️ Agent was aborted. Stopped ${stoppedSubagents} ${stoppedSubagents === 1 ? "sub-agent" : "sub-agents"}.`;
+}
+function resolveSessionEntryForKey(store, sessionKey) {
+	if (!store || !sessionKey) return {};
+	const resolved = resolveSessionStoreEntry({
+		store,
+		sessionKey
+	});
+	if (resolved.existing) return resolved.legacyKeys.length > 0 ? {
+		entry: resolved.existing,
+		key: resolved.normalizedKey,
+		legacyKeys: resolved.legacyKeys
+	} : {
+		entry: resolved.existing,
+		key: resolved.normalizedKey
+	};
+	return {};
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = normalizeOptionalString(key);
+	if (!cleaned) return;
+	const { mainKey, alias } = resolveMainSessionAlias(cfg);
+	return resolveInternalSessionKey({
+		key: cleaned,
+		alias,
+		mainKey
+	});
+}
+function stopSubagentsForRequester(params) {
+	const requesterKey = normalizeRequesterSessionKey(params.cfg, params.requesterSessionKey);
+	if (!requesterKey) return { stopped: 0 };
+	const dedupedRunsByChildKey = /* @__PURE__ */ new Map();
+	for (const run of abortDeps.listSubagentRunsForController(requesterKey)) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		if (!latest) {
+			const existing = dedupedRunsByChildKey.get(childKey);
+			if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+			continue;
+		}
+		const latestControllerSessionKey = normalizeOptionalString(latest?.controllerSessionKey) ?? normalizeOptionalString(latest?.requesterSessionKey);
+		if (latest.runId !== run.runId || latestControllerSessionKey !== requesterKey) continue;
+		const existing = dedupedRunsByChildKey.get(childKey);
+		if (!existing || run.createdAt >= existing.createdAt) dedupedRunsByChildKey.set(childKey, run);
+	}
+	const runs = Array.from(dedupedRunsByChildKey.values());
+	if (runs.length === 0) return { stopped: 0 };
+	const storeCache = /* @__PURE__ */ new Map();
+	const seenChildKeys = /* @__PURE__ */ new Set();
+	let stopped = 0;
+	for (const run of runs) {
+		const childKey = normalizeOptionalString(run.childSessionKey);
+		if (!childKey || seenChildKeys.has(childKey)) continue;
+		seenChildKeys.add(childKey);
+		if (!run.endedAt) {
+			const cleared = clearSessionQueues([childKey]);
+			const parsed = parseAgentSessionKey(childKey);
+			const storePath = resolveStorePath(params.cfg.session?.store, { agentId: parsed?.agentId });
+			let store = storeCache.get(storePath);
+			if (!store) {
+				store = loadSessionStore(storePath);
+				storeCache.set(storePath, store);
+			}
+			const entry = store[childKey];
+			const aborted = abortSessionRunTarget({
+				key: childKey,
+				sessionId: replyRunRegistry.resolveSessionId(childKey) ?? entry?.sessionId
+			});
+			if (abortDeps.markSubagentRunTerminated({
+				runId: run.runId,
+				childSessionKey: childKey,
+				reason: "killed"
+			}) > 0 || aborted || cleared.followupCleared > 0 || cleared.laneCleared > 0) stopped += 1;
+		}
+		const cascadeResult = stopSubagentsForRequester({
+			cfg: params.cfg,
+			requesterSessionKey: childKey
+		});
+		stopped += cascadeResult.stopped;
+	}
+	if (stopped > 0) logVerbose(`abort: stopped ${stopped} subagent run(s) for ${requesterKey}`);
+	return { stopped };
+}
+async function tryFastAbortFromMessage(params) {
+	const { ctx, cfg } = params;
+	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? normalizeOptionalString(ctx.SessionKey);
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(normalizeOptionalLowercaseString(ctx.ChatType) === "group" ? stripMentions(raw, ctx, cfg, resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	})) : raw)) return {
+		handled: false,
+		aborted: false
+	};
+	const commandAuthorized = ctx.CommandAuthorized;
+	const auth = resolveCommandAuthorization({
+		ctx,
+		cfg,
+		commandAuthorized
+	});
+	if (!auth.isAuthorizedSender) return {
+		handled: false,
+		aborted: false
+	};
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const abortKey = targetKey ?? auth.from ?? auth.to;
+	const requesterSessionKey = targetKey ?? ctx.SessionKey ?? abortKey;
+	if (targetKey) {
+		const storePath = resolveStorePath(cfg.session?.store, { agentId });
+		const store = loadSessionStore(storePath);
+		const { entry, key, legacyKeys } = resolveSessionEntryForKey(store, targetKey);
+		const resolvedTargetKey = key ?? targetKey;
+		const acpManager = abortDeps.getAcpSessionManager();
+		if (acpManager.resolveSession({
+			cfg,
+			sessionKey: resolvedTargetKey
+		}).kind !== "none") try {
+			await acpManager.cancelSession({
+				cfg,
+				sessionKey: resolvedTargetKey,
+				reason: "fast-abort"
+			});
+		} catch (error) {
+			logVerbose(`abort: ACP cancel failed for ${resolvedTargetKey}: ${formatErrorMessage(error)}`);
+		}
+		const sessionId = replyRunRegistry.resolveSessionId(resolvedTargetKey) ?? entry?.sessionId;
+		const aborted = abortSessionRunTarget({
+			key: resolvedTargetKey,
+			sessionId
+		});
+		const cleared = clearSessionQueues([resolvedTargetKey, sessionId]);
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey: ctx.SessionKey,
+			targetSessionKey: resolvedTargetKey
+		}) ? resolveAbortCutoffFromContext(ctx) : void 0;
+		if (entry && key) {
+			entry.abortedLastRun = true;
+			applyAbortCutoffToSessionEntry(entry, abortCutoff);
+			entry.updatedAt = Date.now();
+			store[key] = entry;
+			for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete store[legacyKey];
+			await updateSessionStore(storePath, (nextStore) => {
+				const nextEntry = nextStore[key] ?? entry;
+				if (!nextEntry) return;
+				nextEntry.abortedLastRun = true;
+				applyAbortCutoffToSessionEntry(nextEntry, abortCutoff);
+				nextEntry.updatedAt = Date.now();
+				nextStore[key] = nextEntry;
+				for (const legacyKey of legacyKeys ?? []) if (legacyKey !== key) delete nextStore[legacyKey];
+			});
+		} else if (abortKey) setAbortMemory(abortKey, true);
+		const { stopped } = stopSubagentsForRequester({
+			cfg,
+			requesterSessionKey
+		});
+		return {
+			handled: true,
+			aborted,
+			stoppedSubagents: stopped
+		};
+	}
+	if (abortKey) setAbortMemory(abortKey, true);
+	const { stopped } = stopSubagentsForRequester({
+		cfg,
+		requesterSessionKey
+	});
+	return {
+		handled: true,
+		aborted: false,
+		stoppedSubagents: stopped
+	};
+}
+//#endregion
+export { tryFastAbortFromMessage as a, stopSubagentsForRequester as i, formatAbortReplyText as n, resolveSessionEntryForKey as r, abortSessionRunTarget as t };

package/dist/abort.runtime-BW6T_RHD.js

@@ -0,0 +1,2 @@
+import { a as tryFastAbortFromMessage, n as formatAbortReplyText } from "./abort-JN5J8_wx.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-vL-Ncqgp.js";
+export * from "./abort.runtime-BW6T_RHD.js";

package/dist/account-inspect-Cc8fdBnc.d.ts

@@ -0,0 +1,22 @@
+import { i as OpenClawConfig } from "./types.openclaw-BnZ6XBRd.js";
+import { _t as DiscordAccountConfig } from "./types.channels-CjcvDSX0.js";
+import { t as DiscordCredentialStatus } from "./token-i7-HRmBS.js";
+
+//#region extensions/discord/src/account-inspect.d.ts
+type InspectedDiscordAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: DiscordCredentialStatus;
+  configured: boolean;
+  config: DiscordAccountConfig;
+};
+declare function inspectDiscordAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  envToken?: string | null;
+}): InspectedDiscordAccount;
+//#endregion
+export { inspectDiscordAccount as n, InspectedDiscordAccount as t };

package/dist/account-inspect-De43jlwa.js

@@ -0,0 +1,161 @@
+import { c as normalizeOptionalString } from "./string-coerce-LndEvhRk.js";
+import { d as normalizeSecretInputString, o as coerceSecretRef, s as hasConfiguredSecretInput } from "./types.secrets-CJS3n8Im.js";
+import { n as normalizeAccountId } from "./account-id-9_btbLFO.js";
+import { a as tryReadSecretFileSync } from "./secret-file-CfGT0kSh.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-BR8wwaMv.js";
+import "./string-coerce-runtime-CHEMwnph.js";
+import { t as resolveAccountWithDefaultFallback } from "./account-core-Dit8DCsq.js";
+import "./channel-core-D5-DqoJI.js";
+import "./provider-auth-C9zf8LVY.js";
+import "./routing-v6qXDLu-.js";
+import "./secret-input-j3LWYjCS.js";
+import "./secret-input-runtime-CDCvYY2a.js";
+import { n as resolveTelegramAccountConfig, t as mergeTelegramAccountConfig } from "./account-config-Cunp-wJY.js";
+import { a as resolveDefaultTelegramAccountId } from "./accounts-CASCq3sr.js";
+//#region extensions/telegram/src/account-inspect.ts
+function inspectTokenFile(pathValue) {
+	const tokenFile = normalizeOptionalString(pathValue) ?? "";
+	if (!tokenFile) return null;
+	const token = tryReadSecretFileSync(tokenFile, "Telegram bot token", { rejectSymlink: true });
+	return {
+		token: token ?? "",
+		tokenSource: "tokenFile",
+		tokenStatus: token ? "available" : "configured_unavailable"
+	};
+}
+function canResolveEnvSecretRefInReadOnlyPath(params) {
+	const providerConfig = params.cfg.secrets?.providers?.[params.provider];
+	if (!providerConfig) return params.provider === resolveDefaultSecretProviderAlias(params.cfg, "env");
+	if (providerConfig.source !== "env") return false;
+	const allowlist = providerConfig.allowlist;
+	return !allowlist || allowlist.includes(params.id);
+}
+function inspectTokenValue(params) {
+	const ref = coerceSecretRef(params.value, params.cfg.secrets?.defaults);
+	if (ref?.source === "env") {
+		if (!canResolveEnvSecretRefInReadOnlyPath({
+			cfg: params.cfg,
+			provider: ref.provider,
+			id: ref.id
+		})) return {
+			token: "",
+			tokenSource: "env",
+			tokenStatus: "configured_unavailable"
+		};
+		const envValue = normalizeOptionalString(process.env[ref.id]);
+		if (envValue) return {
+			token: envValue,
+			tokenSource: "env",
+			tokenStatus: "available"
+		};
+		return {
+			token: "",
+			tokenSource: "env",
+			tokenStatus: "configured_unavailable"
+		};
+	}
+	const token = normalizeSecretInputString(params.value);
+	if (token) return {
+		token,
+		tokenSource: "config",
+		tokenStatus: "available"
+	};
+	if (hasConfiguredSecretInput(params.value, params.cfg.secrets?.defaults)) return {
+		token: "",
+		tokenSource: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	return null;
+}
+function inspectTelegramAccountPrimary(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const merged = mergeTelegramAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.telegram?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveTelegramAccountConfig(params.cfg, accountId);
+	const accountTokenFile = inspectTokenFile(accountConfig?.tokenFile);
+	if (accountTokenFile) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountTokenFile.token,
+		tokenSource: accountTokenFile.tokenSource,
+		tokenStatus: accountTokenFile.tokenStatus,
+		configured: accountTokenFile.tokenStatus !== "missing",
+		config: merged
+	};
+	const accountToken = inspectTokenValue({
+		cfg: params.cfg,
+		value: accountConfig?.botToken
+	});
+	if (accountToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: accountToken.token,
+		tokenSource: accountToken.tokenSource,
+		tokenStatus: accountToken.tokenStatus,
+		configured: accountToken.tokenStatus !== "missing",
+		config: merged
+	};
+	const channelTokenFile = inspectTokenFile(params.cfg.channels?.telegram?.tokenFile);
+	if (channelTokenFile) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelTokenFile.token,
+		tokenSource: channelTokenFile.tokenSource,
+		tokenStatus: channelTokenFile.tokenStatus,
+		configured: channelTokenFile.tokenStatus !== "missing",
+		config: merged
+	};
+	const channelToken = inspectTokenValue({
+		cfg: params.cfg,
+		value: params.cfg.channels?.telegram?.botToken
+	});
+	if (channelToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: channelToken.tokenStatus !== "missing",
+		config: merged
+	};
+	const envToken = accountId === "default" ? normalizeOptionalString(params.envToken) ?? normalizeOptionalString(process.env.TELEGRAM_BOT_TOKEN) ?? "" : "";
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: envToken,
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(merged.name),
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+}
+function inspectTelegramAccount(params) {
+	return resolveAccountWithDefaultFallback({
+		accountId: params.accountId,
+		normalizeAccountId,
+		resolvePrimary: (accountId) => inspectTelegramAccountPrimary({
+			cfg: params.cfg,
+			accountId,
+			envToken: params.envToken
+		}),
+		hasCredential: (account) => account.tokenSource !== "none",
+		resolveDefaultAccountId: () => resolveDefaultTelegramAccountId(params.cfg)
+	});
+}
+//#endregion
+export { inspectTelegramAccount as t };

package/dist/accounts-BHyUeNl6.d.ts

@@ -0,0 +1,51 @@
+import { i as OpenClawConfig } from "./types.openclaw-BnZ6XBRd.js";
+import { _ as TelegramAccountConfig, v as TelegramActionConfig } from "./types.channels-CjcvDSX0.js";
+import { t as TelegramTransport } from "./fetch-BiGY9A8_.js";
+
+//#region extensions/telegram/src/account-config.d.ts
+declare function resolveTelegramAccountConfig(cfg: OpenClawConfig, accountId: string): TelegramAccountConfig | undefined;
+declare function mergeTelegramAccountConfig(cfg: OpenClawConfig, accountId: string): TelegramAccountConfig;
+//#endregion
+//#region extensions/telegram/src/accounts.d.ts
+type ResolvedTelegramAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "tokenFile" | "config" | "none";
+  config: TelegramAccountConfig;
+};
+type TelegramMediaRuntimeOptions = {
+  token: string;
+  transport?: TelegramTransport;
+  apiRoot?: string;
+  trustedLocalFileRoots?: readonly string[];
+  dangerouslyAllowPrivateNetwork?: boolean;
+};
+declare function listTelegramAccountIds(cfg: OpenClawConfig): string[];
+/** @internal Reset the once-per-process warning flag. Exported for tests only. */
+declare function resetMissingDefaultWarnFlag(): void;
+declare function resolveDefaultTelegramAccountId(cfg: OpenClawConfig): string;
+declare function createTelegramActionGate(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): (key: keyof TelegramActionConfig, defaultValue?: boolean) => boolean;
+declare function resolveTelegramMediaRuntimeOptions(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+  token: string;
+  transport?: TelegramTransport;
+}): TelegramMediaRuntimeOptions;
+type TelegramPollActionGateState = {
+  sendMessageEnabled: boolean;
+  pollEnabled: boolean;
+  enabled: boolean;
+};
+declare function resolveTelegramPollActionGateState(isActionEnabled: (key: keyof TelegramActionConfig, defaultValue?: boolean) => boolean): TelegramPollActionGateState;
+declare function resolveTelegramAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedTelegramAccount;
+declare function listEnabledTelegramAccounts(cfg: OpenClawConfig): ResolvedTelegramAccount[];
+//#endregion
+export { listEnabledTelegramAccounts as a, resolveDefaultTelegramAccountId as c, resolveTelegramPollActionGateState as d, mergeTelegramAccountConfig as f, createTelegramActionGate as i, resolveTelegramAccount as l, TelegramMediaRuntimeOptions as n, listTelegramAccountIds as o, resolveTelegramAccountConfig as p, TelegramPollActionGateState as r, resetMissingDefaultWarnFlag as s, ResolvedTelegramAccount as t, resolveTelegramMediaRuntimeOptions as u };

package/dist/accounts-BVhp4ljB.js

@@ -0,0 +1,107 @@
+import { c as normalizeOptionalString } from "./string-coerce-LndEvhRk.js";
+import { d as normalizeSecretInputString, u as normalizeResolvedSecretInputString } from "./types.secrets-CJS3n8Im.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-9_btbLFO.js";
+import { a as tryReadSecretFileSync } from "./secret-file-CfGT0kSh.js";
+import { t as resolveAccountEntry } from "./account-lookup-CjRBorLg.js";
+import "./string-coerce-runtime-CHEMwnph.js";
+import { c as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-CCE5CQW_.js";
+import "./core-Bnst7YoP.js";
+import "./routing-v6qXDLu-.js";
+import "./secret-input-j3LWYjCS.js";
+//#region extensions/zalo/src/token.ts
+function readTokenFromFile(tokenFile) {
+	return tryReadSecretFileSync(tokenFile, "Zalo token file", { rejectSymlink: true }) ?? "";
+}
+function resolveZaloToken(config, accountId, options) {
+	const resolvedAccountId = normalizeAccountId(accountId ?? config?.defaultAccount);
+	const isDefaultAccount = resolvedAccountId === DEFAULT_ACCOUNT_ID;
+	const baseConfig = config;
+	const accountConfig = resolveAccountEntry(baseConfig?.accounts, normalizeAccountId(resolvedAccountId));
+	const accountHasBotToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "botToken"));
+	if (accountConfig && accountHasBotToken) {
+		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(accountConfig.botToken) : normalizeResolvedSecretInputString({
+			value: accountConfig.botToken,
+			path: `channels.zalo.accounts.${resolvedAccountId}.botToken`
+		});
+		if (token) return {
+			token,
+			source: "config"
+		};
+		const fileToken = readTokenFromFile(accountConfig.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (!accountHasBotToken) {
+		const fileToken = readTokenFromFile(accountConfig?.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (!accountHasBotToken) {
+		const token = options?.allowUnresolvedSecretRef ? normalizeSecretInputString(baseConfig?.botToken) : normalizeResolvedSecretInputString({
+			value: baseConfig?.botToken,
+			path: "channels.zalo.botToken"
+		});
+		if (token) return {
+			token,
+			source: "config"
+		};
+		const fileToken = readTokenFromFile(baseConfig?.tokenFile);
+		if (fileToken) return {
+			token: fileToken,
+			source: "configFile"
+		};
+	}
+	if (isDefaultAccount) {
+		const envToken = process.env.ZALO_BOT_TOKEN?.trim();
+		if (envToken) return {
+			token: envToken,
+			source: "env"
+		};
+	}
+	return {
+		token: "",
+		source: "none"
+	};
+}
+//#endregion
+//#region extensions/zalo/src/accounts.ts
+const { listAccountIds: listZaloAccountIds, resolveDefaultAccountId: resolveDefaultZaloAccountId } = createAccountListHelpers("zalo", { implicitDefaultAccount: {
+	channelKeys: ["botToken", "tokenFile"],
+	envVars: ["ZALO_BOT_TOKEN"]
+} });
+function mergeZaloAccountConfig(cfg, accountId) {
+	return resolveMergedAccountConfig({
+		channelConfig: cfg.channels?.zalo,
+		accounts: (cfg.channels?.zalo)?.accounts,
+		accountId,
+		omitKeys: ["defaultAccount"]
+	});
+}
+function resolveZaloAccount(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 });
+	return {
+		accountId,
+		name: normalizeOptionalString(merged.name),
+		enabled,
+		token: tokenResolution.token,
+		tokenSource: tokenResolution.source,
+		config: merged
+	};
+}
+function listEnabledZaloAccounts(cfg) {
+	return listZaloAccountIds(cfg).map((accountId) => resolveZaloAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled);
+}
+//#endregion
+export { resolveZaloToken as a, resolveZaloAccount as i, listZaloAccountIds as n, resolveDefaultZaloAccountId as r, listEnabledZaloAccounts as t };

package/dist/accounts-BrghLdDN.d.ts

@@ -0,0 +1,34 @@
+import { i as OpenClawConfig } from "./types.openclaw-BnZ6XBRd.js";
+import { _t as DiscordAccountConfig, vt as DiscordActionConfig } from "./types.channels-CjcvDSX0.js";
+import { t as DiscordCredentialStatus } from "./token-i7-HRmBS.js";
+
+//#region extensions/discord/src/accounts.d.ts
+type ResolvedDiscordAccount = {
+  accountId: string;
+  enabled: boolean;
+  name?: string;
+  token: string;
+  tokenSource: "env" | "config" | "none";
+  tokenStatus: DiscordCredentialStatus;
+  config: DiscordAccountConfig;
+};
+declare const listDiscordAccountIds: (cfg: OpenClawConfig) => string[];
+declare const resolveDefaultDiscordAccountId: (cfg: OpenClawConfig) => string;
+declare function resolveDiscordAccountConfig(cfg: OpenClawConfig, accountId: string): DiscordAccountConfig | undefined;
+declare function mergeDiscordAccountConfig(cfg: OpenClawConfig, accountId: string): DiscordAccountConfig;
+declare function createDiscordActionGate(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): (key: keyof DiscordActionConfig, defaultValue?: boolean) => boolean;
+declare function resolveDiscordAccount(params: {
+  cfg: OpenClawConfig;
+  accountId?: string | null;
+}): ResolvedDiscordAccount;
+declare function resolveDiscordMaxLinesPerMessage(params: {
+  cfg: OpenClawConfig;
+  discordConfig?: DiscordAccountConfig | null;
+  accountId?: string | null;
+}): number | undefined;
+declare function listEnabledDiscordAccounts(cfg: OpenClawConfig): ResolvedDiscordAccount[];
+//#endregion
+export { mergeDiscordAccountConfig as a, resolveDiscordAccountConfig as c, listEnabledDiscordAccounts as i, resolveDiscordMaxLinesPerMessage as l, createDiscordActionGate as n, resolveDefaultDiscordAccountId as o, listDiscordAccountIds as r, resolveDiscordAccount as s, ResolvedDiscordAccount as t };