@gaodefa/daocore 2026.5.25 → 2026.5.27

package/dist/abort-By0wxKlI.js

@@ -0,0 +1,277 @@
+import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import { i as formatErrorMessage } from "./errors-DCgU20d6.js";
+import { _ as resolveSessionAgentId } from "./agent-scope-BvhOCChS.js";
+import { c as parseAgentSessionKey, n as isAcpSessionKey } from "./session-key-utils-Ce_xWkNq.js";
+import { r as logVerbose } from "./globals-CTkTxjGR.js";
+import { u as resolveStorePath } from "./paths-8MFrTNIB.js";
+import { F as resolveSessionStoreEntry, t as loadSessionStore } from "./store-load-BIBESNhm.js";
+import { u as updateSessionStore } from "./store-BMkMyEnW.js";
+import "./sessions-CevgdiMi.js";
+import { t as getAcpSessionManager } from "./manager-BD9cxlt7.js";
+import { f as replyRunRegistry } from "./reply-run-registry-CT51xRXu.js";
+import { n as abortEmbeddedPiRun, p as resolveActiveEmbeddedRunSessionId } from "./runs-g3A6Mtnd.js";
+import { c as resolveMainSessionAlias, s as resolveInternalSessionKey } from "./sessions-helpers-BEPGfvTO.js";
+import { a as clearSessionQueues } from "./queue-B_hYGFDy.js";
+import { f as markSubagentRunTerminated, o as getLatestSubagentRunByChildSessionKey, u as listSubagentRunsForController } from "./subagent-registry-BosUdBW6.js";
+import { i as resolveConversationBindingContextFromMessage } from "./conversation-binding-input-BYricug4.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-CxYnZfYf.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-DU3pYaEB.js";
+import { t as resolveCommandAuthorization } from "./command-auth-Ch1LhR0O.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-cRHrB_Kx.js";
+import { t as resolveEffectiveResetTargetSessionKey } from "./acp-reset-target-TsbuPKfb.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 resolveStoredSessionId(params) {
+	const agentId = resolveSessionAgentId({
+		sessionKey: params.sessionKey,
+		config: params.cfg
+	});
+	const storePath = resolveStorePath(params.cfg.session?.store, { agentId });
+	try {
+		return resolveSessionEntryForKey(loadSessionStore(storePath), params.sessionKey).entry?.sessionId;
+	} catch {
+		return;
+	}
+}
+function resolveBoundAcpAbortTargetSessionKey(params) {
+	const bindingContext = resolveConversationBindingContextFromMessage({
+		cfg: params.cfg,
+		ctx: params.ctx
+	});
+	if (!bindingContext) return;
+	return resolveEffectiveResetTargetSessionKey({
+		cfg: params.cfg,
+		channel: bindingContext.channel,
+		accountId: bindingContext.accountId,
+		conversationId: bindingContext.conversationId,
+		parentConversationId: bindingContext.parentConversationId,
+		activeSessionKey: params.activeSessionKey,
+		skipConfiguredFallbackWhenActiveSessionNonAcp: false,
+		fallbackToActiveAcpWhenUnbound: false
+	});
+}
+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 commandSessionKey = normalizeOptionalString(ctx.SessionKey) ?? normalizeOptionalString(ctx.ParentSessionKey);
+	const targetKey = normalizeOptionalString(ctx.CommandTargetSessionKey) ?? commandSessionKey;
+	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 conversationBoundAcpTargetKey = commandSessionKey ? resolveBoundAcpAbortTargetSessionKey({
+			ctx,
+			cfg,
+			activeSessionKey: commandSessionKey
+		}) : void 0;
+		const boundAcpTargetKey = !isAcpSessionKey(resolvedTargetKey) ? conversationBoundAcpTargetKey : void 0;
+		const abortTargetKeys = [resolvedTargetKey];
+		if (boundAcpTargetKey && boundAcpTargetKey !== resolvedTargetKey) abortTargetKeys.push(boundAcpTargetKey);
+		const acpManager = abortDeps.getAcpSessionManager();
+		for (const acpTargetKey of abortTargetKeys.filter(isAcpSessionKey)) {
+			if (acpManager.resolveSession({
+				cfg,
+				sessionKey: acpTargetKey
+			}).kind === "none") continue;
+			try {
+				await acpManager.cancelSession({
+					cfg,
+					sessionKey: acpTargetKey,
+					reason: "fast-abort"
+				});
+			} catch (error) {
+				logVerbose(`abort: ACP cancel failed for ${acpTargetKey}: ${formatErrorMessage(error)}`);
+			}
+		}
+		const sourceAbortKey = commandSessionKey && !abortTargetKeys.includes(commandSessionKey) && conversationBoundAcpTargetKey && abortTargetKeys.includes(conversationBoundAcpTargetKey) ? commandSessionKey : void 0;
+		const sessionIdsByKey = new Map(abortTargetKeys.map((abortTargetKey) => [abortTargetKey, replyRunRegistry.resolveSessionId(abortTargetKey) ?? (abortTargetKey === resolvedTargetKey ? entry?.sessionId : resolveStoredSessionId({
+			cfg,
+			sessionKey: abortTargetKey
+		}))]));
+		let aborted = false;
+		for (const abortTargetKey of abortTargetKeys) aborted = abortSessionRunTarget({
+			key: abortTargetKey,
+			sessionId: sessionIdsByKey.get(abortTargetKey)
+		}) || aborted;
+		const sourceSessionId = sourceAbortKey ? replyRunRegistry.resolveSessionId(sourceAbortKey) ?? resolveStoredSessionId({
+			cfg,
+			sessionKey: sourceAbortKey
+		}) : void 0;
+		if (sourceAbortKey) aborted = abortSessionRunTarget({
+			key: sourceAbortKey,
+			sessionId: sourceSessionId
+		}) || aborted;
+		const cleared = clearSessionQueues(abortTargetKeys.flatMap((abortTargetKey) => [abortTargetKey, sessionIdsByKey.get(abortTargetKey)]).concat(sourceAbortKey, sourceSessionId));
+		if (cleared.followupCleared > 0 || cleared.laneCleared > 0) logVerbose(`abort: cleared followups=${cleared.followupCleared} lane=${cleared.laneCleared} keys=${cleared.keys.join(",")}`);
+		const abortCutoff = shouldPersistAbortCutoff({
+			commandSessionKey,
+			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-C7zfjxBp.js

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

package/dist/abort.runtime.js

@@ -1 +1 @@
-export * from "./abort.runtime-DNoavlKn.js";
+export * from "./abort.runtime-C7zfjxBp.js";

package/dist/account-inspect-DTeLlJz-.js

@@ -0,0 +1,173 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { m as FsSafeError } from "./path-BlG8lhgR.js";
+import { d as normalizeSecretInputString, o as coerceSecretRef, s as hasConfiguredSecretInput } from "./types.secrets-Ct1DNG7D.js";
+import { n as normalizeAccountId } from "./account-id-B32J-iNN.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Yf6gWwVs.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-D77qqtrn.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as resolveAccountWithDefaultFallback } from "./account-core-B_TIp73g.js";
+import "./channel-core-DDZnTvT6.js";
+import "./provider-auth-DBNffzx5.js";
+import "./routing-tpBhvjSA.js";
+import "./secret-input-s8BgZnEq.js";
+import "./security-runtime-ZkIitjef.js";
+import "./secret-input-runtime-CUdvBmcs.js";
+import { n as resolveTelegramAccountConfig, t as mergeTelegramAccountConfig } from "./account-config-CK57oli6.js";
+import { a as resolveDefaultTelegramAccountId } from "./accounts-B776XBaL.js";
+//#region extensions/telegram/src/account-inspect.ts
+function inspectTokenFile(pathValue) {
+	const tokenFile = normalizeOptionalString(pathValue) ?? "";
+	if (!tokenFile) return null;
+	let token;
+	try {
+		token = tryReadSecretFileSync(tokenFile, "Telegram bot token", { rejectSymlink: true });
+	} catch (error) {
+		if (!(error instanceof FsSafeError)) throw error;
+		return {
+			token: "",
+			tokenSource: "tokenFile",
+			tokenStatus: "configured_unavailable"
+		};
+	}
+	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-B776XBaL.js

@@ -0,0 +1,119 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { t as isTruthyEnvValue } from "./env-BFewh9mV.js";
+import { n as normalizeAccountId, r as normalizeOptionalAccountId } from "./account-id-B32J-iNN.js";
+import { t as createSubsystemLogger } from "./subsystem-CK3I9R1L.js";
+import "./runtime-env-B7syXtKu.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { t as createAccountActionGate } from "./account-action-gate-C8yxR-TG.js";
+import { t as resolveAccountWithDefaultFallback } from "./account-core-B_TIp73g.js";
+import { n as formatSetExplicitDefaultInstruction } from "./default-account-warnings-CK3UKJwX.js";
+import "./routing-tpBhvjSA.js";
+import { t as resolveTelegramToken } from "./token-D-FQ8AQz.js";
+import { n as resolveTelegramAccountConfig, t as mergeTelegramAccountConfig } from "./account-config-CK57oli6.js";
+import { r as resolveDefaultTelegramAccountSelection, t as listTelegramAccountIds$1 } from "./account-selection-CnEN2ytn.js";
+import util from "node:util";
+//#region extensions/telegram/src/accounts.ts
+let log = null;
+function getLog() {
+	if (!log) log = createSubsystemLogger("telegram/accounts");
+	return log;
+}
+function formatDebugArg(value) {
+	if (typeof value === "string") return value;
+	if (value instanceof Error) return value.stack ?? value.message;
+	return util.inspect(value, {
+		colors: false,
+		depth: null,
+		compact: true,
+		breakLength: Infinity
+	});
+}
+const debugAccounts = (...args) => {
+	if (isTruthyEnvValue(process.env.DAOCORE_DEBUG_TELEGRAM_ACCOUNTS)) {
+		const parts = args.map((arg) => formatDebugArg(arg));
+		getLog().warn(parts.join(" ").trim());
+	}
+};
+function listTelegramAccountIds(cfg) {
+	const ids = listTelegramAccountIds$1(cfg);
+	debugAccounts("listTelegramAccountIds", ids);
+	return ids;
+}
+let emittedMissingDefaultWarn = false;
+/** @internal Reset the once-per-process warning flag. Exported for tests only. */
+function resetMissingDefaultWarnFlag() {
+	emittedMissingDefaultWarn = false;
+}
+function resolveDefaultTelegramAccountId(cfg) {
+	const selection = resolveDefaultTelegramAccountSelection(cfg);
+	if (selection.shouldWarnMissingDefault && !emittedMissingDefaultWarn) {
+		emittedMissingDefaultWarn = true;
+		getLog().warn(`channels.telegram: accounts.default is missing; falling back to "${selection.accountId}". ${formatSetExplicitDefaultInstruction("telegram")} to avoid routing surprises in multi-account setups.`);
+	}
+	return selection.accountId;
+}
+function createTelegramActionGate(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultTelegramAccountId(params.cfg));
+	return createAccountActionGate({
+		baseActions: params.cfg.channels?.telegram?.actions,
+		accountActions: resolveTelegramAccountConfig(params.cfg, accountId)?.actions
+	});
+}
+function resolveTelegramMediaRuntimeOptions(params) {
+	const normalizedAccountId = normalizeOptionalAccountId(params.accountId);
+	const accountCfg = normalizedAccountId ? mergeTelegramAccountConfig(params.cfg, normalizedAccountId) : params.cfg.channels?.telegram;
+	return {
+		token: params.token,
+		transport: params.transport,
+		apiRoot: accountCfg?.apiRoot,
+		trustedLocalFileRoots: accountCfg?.trustedLocalFileRoots,
+		dangerouslyAllowPrivateNetwork: accountCfg?.network?.dangerouslyAllowPrivateNetwork
+	};
+}
+function resolveTelegramPollActionGateState(isActionEnabled) {
+	const sendMessageEnabled = isActionEnabled("sendMessage");
+	const pollEnabled = isActionEnabled("poll");
+	return {
+		sendMessageEnabled,
+		pollEnabled,
+		enabled: sendMessageEnabled && pollEnabled
+	};
+}
+function resolveTelegramAccount(params) {
+	const baseEnabled = params.cfg.channels?.telegram?.enabled !== false;
+	const resolve = (accountId) => {
+		const merged = mergeTelegramAccountConfig(params.cfg, accountId);
+		const accountEnabled = merged.enabled !== false;
+		const enabled = baseEnabled && accountEnabled;
+		const tokenResolution = resolveTelegramToken(params.cfg, { accountId });
+		debugAccounts("resolve", {
+			accountId,
+			enabled,
+			tokenSource: tokenResolution.source
+		});
+		return {
+			accountId,
+			enabled,
+			name: normalizeOptionalString(merged.name),
+			token: tokenResolution.token,
+			tokenSource: tokenResolution.source,
+			config: merged
+		};
+	};
+	return resolveAccountWithDefaultFallback({
+		accountId: params.accountId,
+		normalizeAccountId,
+		resolvePrimary: resolve,
+		hasCredential: (account) => account.tokenSource !== "none",
+		resolveDefaultAccountId: () => resolveDefaultTelegramAccountId(params.cfg)
+	});
+}
+function listEnabledTelegramAccounts(cfg) {
+	if (!(cfg.channels?.telegram?.enabled !== false)) return [];
+	return listTelegramAccountIds(cfg).filter((accountId) => mergeTelegramAccountConfig(cfg, accountId).enabled !== false).map((accountId) => resolveTelegramAccount({
+		cfg,
+		accountId
+	}));
+}
+//#endregion
+export { resolveDefaultTelegramAccountId as a, resolveTelegramPollActionGateState as c, resetMissingDefaultWarnFlag as i, listEnabledTelegramAccounts as n, resolveTelegramAccount as o, listTelegramAccountIds as r, resolveTelegramMediaRuntimeOptions as s, createTelegramActionGate as t };

package/dist/accounts-CLyZILFF.js

@@ -0,0 +1,107 @@
+import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
+import { d as normalizeSecretInputString, u as normalizeResolvedSecretInputString } from "./types.secrets-Ct1DNG7D.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Yf6gWwVs.js";
+import { t as resolveAccountEntry } from "./account-lookup-CQEoGO1F.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { c as resolveMergedAccountConfig, t as createAccountListHelpers } from "./account-helpers-BEXOONiv.js";
+import "./core-BV0irASW.js";
+import "./routing-tpBhvjSA.js";
+import "./secret-input-s8BgZnEq.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 };