vora-ai 0.1.1 → 0.1.2

package/dist/abort-Djmd94Ev.js

@@ -0,0 +1,192 @@
+import { r as logVerbose } from "./globals-DNhziPZz.js";
+import { T as parseAgentSessionKey } from "./session-key-BIrdMs11.js";
+import { v as resolveSessionAgentId } from "./agent-scope-IH0R738K.js";
+import { r as loadSessionStore, s as resolveSessionStoreEntry, u as updateSessionStore } from "./store-BLLApnqD.js";
+import "./sessions-7yi0rMRH.js";
+import { l as resolveStorePath } from "./paths-dFp6bjkV.js";
+import { It as abortEmbeddedPiRun, at as listSubagentRunsForController, nn as resolveInternalSessionKey, nt as getLatestSubagentRunByChildSessionKey, rn as resolveMainSessionAlias, st as markSubagentRunTerminated } from "./vora-embedded-runner-CTzdsAB9.js";
+import { s as clearSessionQueues } from "./content-blocks-9GCn5hEf.js";
+import { n as getAcpSessionManager } from "./manager-BfZUkAlZ.js";
+import { i as setAbortMemory, n as isAbortRequestText } from "./abort-primitives-jQexhiQK.js";
+import { o as stripMentions, s as stripStructuralPrefixes } from "./mentions-D-emnAhx.js";
+import { t as resolveCommandAuthorization } from "./command-auth-DRMNgiaT.js";
+import { a as shouldPersistAbortCutoff, i as resolveAbortCutoffFromContext, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-BW9X8atp.js";
+const abortDeps = {
+	getAcpSessionManager,
+	abortEmbeddedPiRun,
+	getLatestSubagentRunByChildSessionKey,
+	listSubagentRunsForController,
+	markSubagentRunTerminated
+};
+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 resolveAbortTargetKey(ctx) {
+	const target = ctx.CommandTargetSessionKey?.trim();
+	if (target) return target;
+	return ctx.SessionKey?.trim() || void 0;
+}
+function normalizeRequesterSessionKey(cfg, key) {
+	const cleaned = key?.trim();
+	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 = run.childSessionKey?.trim();
+		if (!childKey) continue;
+		const latest = abortDeps.getLatestSubagentRunByChildSessionKey(childKey);
+		const latestControllerSessionKey = latest?.controllerSessionKey?.trim() || latest?.requesterSessionKey?.trim();
+		if (!latest || 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 = run.childSessionKey?.trim();
+		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 sessionId = store[childKey]?.sessionId;
+			const aborted = sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false;
+			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 = resolveAbortTargetKey(ctx);
+	const agentId = resolveSessionAgentId({
+		sessionKey: targetKey ?? ctx.SessionKey ?? "",
+		config: cfg
+	});
+	const raw = stripStructuralPrefixes(ctx.CommandBody ?? ctx.RawBody ?? ctx.Body ?? "");
+	if (!isAbortRequestText(ctx.ChatType?.trim().toLowerCase() === "group" ? stripMentions(raw, ctx, cfg, agentId) : 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 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}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const sessionId = entry?.sessionId;
+		const aborted = sessionId ? abortDeps.abortEmbeddedPiRun(sessionId) : false;
+		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 i, resolveSessionEntryForKey as n, stopSubagentsForRequester as r, formatAbortReplyText as t };

package/dist/abort-cutoff.runtime-D3YFXjr0.js

@@ -0,0 +1,20 @@
+import { u as updateSessionStore } from "./store-BLLApnqD.js";
+import { n as hasAbortCutoff, t as applyAbortCutoffToSessionEntry } from "./abort-cutoff-BW9X8atp.js";
+//#region src/auto-reply/reply/abort-cutoff.runtime.ts
+async function clearAbortCutoffInSessionRuntime(params) {
+	const { sessionEntry, sessionStore, sessionKey, storePath } = params;
+	if (!sessionEntry || !sessionStore || !sessionKey || !hasAbortCutoff(sessionEntry)) return false;
+	applyAbortCutoffToSessionEntry(sessionEntry, void 0);
+	sessionEntry.updatedAt = Date.now();
+	sessionStore[sessionKey] = sessionEntry;
+	if (storePath) await updateSessionStore(storePath, (store) => {
+		const existing = store[sessionKey] ?? sessionEntry;
+		if (!existing) return;
+		applyAbortCutoffToSessionEntry(existing, void 0);
+		existing.updatedAt = Date.now();
+		store[sessionKey] = existing;
+	});
+	return true;
+}
+//#endregion
+export { clearAbortCutoffInSessionRuntime };

package/dist/abort-primitives-jQexhiQK.js

@@ -0,0 +1,92 @@
+import { p as normalizeCommandBody } from "./commands-registry-D9dP9erM.js";
+//#region src/auto-reply/reply/abort-primitives.ts
+const ABORT_TRIGGERS = new Set([
+	"stop",
+	"esc",
+	"abort",
+	"wait",
+	"exit",
+	"interrupt",
+	"detente",
+	"deten",
+	"detén",
+	"arrete",
+	"arrête",
+	"停止",
+	"やめて",
+	"止めて",
+	"रुको",
+	"توقف",
+	"стоп",
+	"остановись",
+	"останови",
+	"остановить",
+	"прекрати",
+	"halt",
+	"anhalten",
+	"aufhören",
+	"hoer auf",
+	"stopp",
+	"pare",
+	"stop vora",
+	"vora stop",
+	"stop action",
+	"stop current action",
+	"stop run",
+	"stop current run",
+	"stop agent",
+	"stop the agent",
+	"stop don't do anything",
+	"stop dont do anything",
+	"stop do not do anything",
+	"stop doing anything",
+	"do not do that",
+	"please stop",
+	"stop please"
+]);
+const ABORT_MEMORY = /* @__PURE__ */ new Map();
+const ABORT_MEMORY_MAX = 2e3;
+const TRAILING_ABORT_PUNCTUATION_RE = /[.!?…,，。;；:：'"’”)\]}]+$/u;
+function normalizeAbortTriggerText(text) {
+	return text.trim().toLowerCase().replace(/[’`]/g, "'").replace(/\s+/g, " ").replace(TRAILING_ABORT_PUNCTUATION_RE, "").trim();
+}
+function isAbortTrigger(text) {
+	if (!text) return false;
+	const normalized = normalizeAbortTriggerText(text);
+	return ABORT_TRIGGERS.has(normalized);
+}
+function isAbortRequestText(text, options) {
+	if (!text) return false;
+	const normalized = normalizeCommandBody(text, options).trim();
+	if (!normalized) return false;
+	const normalizedLower = normalized.toLowerCase();
+	return normalizedLower === "/stop" || normalizeAbortTriggerText(normalizedLower) === "/stop" || isAbortTrigger(normalizedLower);
+}
+function getAbortMemory(key) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	return ABORT_MEMORY.get(normalized);
+}
+function pruneAbortMemory() {
+	if (ABORT_MEMORY.size <= ABORT_MEMORY_MAX) return;
+	const excess = ABORT_MEMORY.size - ABORT_MEMORY_MAX;
+	let removed = 0;
+	for (const entryKey of ABORT_MEMORY.keys()) {
+		ABORT_MEMORY.delete(entryKey);
+		removed += 1;
+		if (removed >= excess) break;
+	}
+}
+function setAbortMemory(key, value) {
+	const normalized = key.trim();
+	if (!normalized) return;
+	if (!value) {
+		ABORT_MEMORY.delete(normalized);
+		return;
+	}
+	if (ABORT_MEMORY.has(normalized)) ABORT_MEMORY.delete(normalized);
+	ABORT_MEMORY.set(normalized, true);
+	pruneAbortMemory();
+}
+//#endregion
+export { setAbortMemory as i, isAbortRequestText as n, isAbortTrigger as r, getAbortMemory as t };

package/dist/abort.runtime-DuVJhu8X.js

@@ -0,0 +1,2 @@
+import { i as tryFastAbortFromMessage, t as formatAbortReplyText } from "./abort-Djmd94Ev.js";
+export { formatAbortReplyText, tryFastAbortFromMessage };

package/dist/access-BwgN6lbJ.js

@@ -0,0 +1,82 @@
+import { i as resolveOpenProviderRuntimeGroupPolicy } from "./runtime-group-policy-BPxHuPda.js";
+import { t as resolveCommandAuthorizedFromAuthorizers } from "./command-gating-HO-bVa6h.js";
+import "./config-runtime-7XdHOt-f.js";
+import "./command-auth--mhSBzSz.js";
+import { d as resolveDiscordOwnerAccess, l as resolveDiscordGuildEntry, n as isDiscordGroupAllowedByPolicy, s as resolveDiscordChannelConfigWithFallback, u as resolveDiscordMemberAccessState } from "./allow-list-BFJp0pl8.js";
+//#region extensions/discord/src/voice/access.ts
+async function authorizeDiscordVoiceIngress(params) {
+	const groupPolicy = params.groupPolicy ?? resolveOpenProviderRuntimeGroupPolicy({
+		providerConfigPresent: params.cfg.channels?.discord !== void 0,
+		groupPolicy: params.discordConfig.groupPolicy,
+		defaultGroupPolicy: params.cfg.channels?.defaults?.groupPolicy
+	}).groupPolicy;
+	const guildInfo = resolveDiscordGuildEntry({
+		guild: params.guild ?? {
+			id: params.guildId,
+			...params.guildName ? { name: params.guildName } : {}
+		},
+		guildId: params.guildId,
+		guildEntries: params.discordConfig.guilds
+	});
+	const channelConfig = params.channelId ? resolveDiscordChannelConfigWithFallback({
+		guildInfo,
+		channelId: params.channelId,
+		channelName: params.channelName,
+		channelSlug: params.channelSlug,
+		parentId: params.parentId,
+		parentName: params.parentName,
+		parentSlug: params.parentSlug,
+		scope: params.scope
+	}) : null;
+	if (channelConfig?.enabled === false) return {
+		ok: false,
+		message: "This channel is disabled."
+	};
+	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+	if (!params.channelId && groupPolicy === "allowlist" && channelAllowlistConfigured) return {
+		ok: false,
+		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
+	};
+	const channelAllowed = channelConfig ? channelConfig.allowed !== false : !channelAllowlistConfigured;
+	if (!isDiscordGroupAllowedByPolicy({
+		groupPolicy,
+		guildAllowlisted: Boolean(guildInfo),
+		channelAllowlistConfigured,
+		channelAllowed
+	}) || channelConfig?.allowed === false) return {
+		ok: false,
+		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`
+	};
+	const { hasAccessRestrictions, memberAllowed } = resolveDiscordMemberAccessState({
+		channelConfig,
+		guildInfo,
+		memberRoleIds: params.memberRoleIds,
+		sender: params.sender,
+		allowNameMatching: false
+	});
+	const { ownerAllowList, ownerAllowed } = resolveDiscordOwnerAccess({
+		allowFrom: params.discordConfig.allowFrom ?? params.discordConfig.dm?.allowFrom ?? [],
+		sender: params.sender,
+		allowNameMatching: false
+	});
+	const useAccessGroups = params.useAccessGroups ?? params.cfg.commands?.useAccessGroups !== false;
+	return resolveCommandAuthorizedFromAuthorizers({
+		useAccessGroups,
+		authorizers: useAccessGroups ? [{
+			configured: ownerAllowList != null,
+			allowed: ownerAllowed
+		}, {
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}] : [{
+			configured: hasAccessRestrictions,
+			allowed: memberAllowed
+		}],
+		modeWhenAccessGroupsOff: "configured"
+	}) ? { ok: true } : {
+		ok: false,
+		message: "You are not authorized to use this command."
+	};
+}
+//#endregion
+export { authorizeDiscordVoiceIngress as t };

package/dist/account-inspect-CaB8WaGt.js

@@ -0,0 +1,158 @@
+import { a as hasConfiguredSecretInput, i as coerceSecretRef, l as normalizeSecretInputString } from "./types.secrets-CxoujPzV.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-D5ynmOGd.js";
+import { _ as normalizeAccountId } from "./session-key-BIrdMs11.js";
+import { n as resolveAccountWithDefaultFallback } from "./account-core-BxpV-R9y.js";
+import { i as tryReadSecretFileSync } from "./secret-file-Dv42g1FG.js";
+import "./core-BUGytW-Q.js";
+import "./routing-D3QxKp24.js";
+import "./secret-input-DJ-sTcOE.js";
+import "./config-runtime-7XdHOt-f.js";
+import "./provider-auth-jMZEkCMg.js";
+import { c as resolveTelegramAccountConfig, i as mergeTelegramAccountConfig, o as resolveDefaultTelegramAccountId } from "./accounts-CsV02kRm.js";
+//#region extensions/telegram/src/account-inspect.ts
+function inspectTokenFile(pathValue) {
+	const tokenFile = typeof pathValue === "string" ? pathValue.trim() : "";
+	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 = process.env[ref.id];
+		if (envValue && envValue.trim()) return {
+			token: envValue.trim(),
+			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: merged.name?.trim() || void 0,
+		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: merged.name?.trim() || void 0,
+		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: merged.name?.trim() || void 0,
+		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: merged.name?.trim() || void 0,
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: channelToken.tokenStatus !== "missing",
+		config: merged
+	};
+	const envToken = accountId === "default" ? (params.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim() : "";
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: envToken,
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		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/account-inspect-Y-UwwrdI.js

@@ -0,0 +1,81 @@
+import { a as hasConfiguredSecretInput, l as normalizeSecretInputString } from "./types.secrets-CxoujPzV.js";
+import { _ as normalizeAccountId } from "./session-key-BIrdMs11.js";
+import "./secret-input-DJ-sTcOE.js";
+import { a as resolveDefaultDiscordAccountId, i as mergeDiscordAccountConfig, s as resolveDiscordAccountConfig } from "./accounts-B_552ZEj.js";
+//#region extensions/discord/src/account-inspect.ts
+function inspectDiscordTokenValue(value) {
+	const normalized = normalizeSecretInputString(value);
+	if (normalized) return {
+		token: normalized.replace(/^Bot\s+/i, ""),
+		tokenSource: "config",
+		tokenStatus: "available"
+	};
+	if (hasConfiguredSecretInput(value)) return {
+		token: "",
+		tokenSource: "config",
+		tokenStatus: "configured_unavailable"
+	};
+	return null;
+}
+function inspectDiscordAccount(params) {
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
+	const merged = mergeDiscordAccountConfig(params.cfg, accountId);
+	const enabled = params.cfg.channels?.discord?.enabled !== false && merged.enabled !== false;
+	const accountConfig = resolveDiscordAccountConfig(params.cfg, accountId);
+	const hasAccountToken = Boolean(accountConfig && Object.prototype.hasOwnProperty.call(accountConfig, "token"));
+	const accountToken = inspectDiscordTokenValue(accountConfig?.token);
+	if (accountToken) return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: accountToken.token,
+		tokenSource: accountToken.tokenSource,
+		tokenStatus: accountToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	if (hasAccountToken) return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+	const channelToken = inspectDiscordTokenValue(params.cfg.channels?.discord?.token);
+	if (channelToken) return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: channelToken.token,
+		tokenSource: channelToken.tokenSource,
+		tokenStatus: channelToken.tokenStatus,
+		configured: true,
+		config: merged
+	};
+	const envToken = accountId === "default" ? normalizeSecretInputString(params.envToken ?? process.env.DISCORD_BOT_TOKEN) : void 0;
+	if (envToken) return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: envToken.replace(/^Bot\s+/i, ""),
+		tokenSource: "env",
+		tokenStatus: "available",
+		configured: true,
+		config: merged
+	};
+	return {
+		accountId,
+		enabled,
+		name: merged.name?.trim() || void 0,
+		token: "",
+		tokenSource: "none",
+		tokenStatus: "missing",
+		configured: false,
+		config: merged
+	};
+}
+//#endregion
+export { inspectDiscordAccount as t };

package/dist/account-resolution-BT04kbsj.js

@@ -0,0 +1,30 @@
+import "./utils-BiWzD1kh.js";
+import "./discord-account-D3FdL9-Y.js";
+import "./slack-account-BD0B6Ui7.js";
+import "./telegram-account-CDUpVNkR.js";
+import "./signal-account-D4w1A22M.js";
+//#region src/plugin-sdk/account-resolution.ts
+/** Resolve an account by id, then fall back to the default account when the primary lacks credentials. */
+function resolveAccountWithDefaultFallback(params) {
+	const hasExplicitAccountId = Boolean(params.accountId?.trim());
+	const normalizedAccountId = params.normalizeAccountId(params.accountId);
+	const primary = params.resolvePrimary(normalizedAccountId);
+	if (hasExplicitAccountId || params.hasCredential(primary)) return primary;
+	const fallbackId = params.resolveDefaultAccountId();
+	if (fallbackId === normalizedAccountId) return primary;
+	const fallback = params.resolvePrimary(fallbackId);
+	if (!params.hasCredential(fallback)) return primary;
+	return fallback;
+}
+/** List normalized configured account ids from a raw channel account record map. */
+function listConfiguredAccountIds(params) {
+	if (!params.accounts) return [];
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of Object.keys(params.accounts)) {
+		if (!key) continue;
+		ids.add(params.normalizeAccountId(key));
+	}
+	return [...ids];
+}
+//#endregion
+export { resolveAccountWithDefaultFallback as n, listConfiguredAccountIds as t };