@openclaw/discord 2026.8.2 → 2026.8.34

package/dist/sender-identity-Dt0imZyY.js

@@ -1,43 +0,0 @@
-import { x as formatDiscordUserTag } from "./allow-list-C2JuH-R0.js";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/discord/src/monitor/sender-identity.ts
-function resolveDiscordWebhookId(message) {
-	const candidate = message.webhookId ?? message.webhook_id;
-	return typeof candidate === "string" && candidate.trim() ? candidate.trim() : null;
-}
-function resolveDiscordSenderIdentity(params) {
-	const pkInfo = params.pluralkitInfo ?? null;
-	const pkMember = pkInfo?.member ?? void 0;
-	const pkSystem = pkInfo?.system ?? void 0;
-	const memberId = pkMember?.id?.trim();
-	const memberName = (pkMember?.display_name ?? pkMember?.name ?? "")?.trim();
-	if (memberId && memberName) {
-		const systemName = pkSystem?.name?.trim();
-		const label = systemName ? `${memberName} (PK:${systemName})` : `${memberName} (PK)`;
-		return {
-			id: memberId,
-			name: memberName,
-			tag: normalizeOptionalString(pkMember?.name),
-			label,
-			isPluralKit: true,
-			pluralkit: {
-				memberId,
-				memberName,
-				systemId: normalizeOptionalString(pkSystem?.id),
-				systemName
-			}
-		};
-	}
-	const senderTag = formatDiscordUserTag(params.author);
-	const senderDisplay = params.member?.nickname ?? params.member?.nick ?? params.author.globalName ?? params.author.username;
-	const senderLabel = senderDisplay && senderTag && senderDisplay !== senderTag ? `${senderDisplay} (${senderTag})` : senderDisplay ?? senderTag ?? params.author.id;
-	return {
-		id: params.author.id,
-		name: params.author.username ?? void 0,
-		tag: senderTag,
-		label: senderLabel,
-		isPluralKit: false
-	};
-}
-//#endregion
-export { resolveDiscordWebhookId as n, resolveDiscordSenderIdentity as t };

package/dist/shared-BNesVA4P.js

@@ -1,215 +0,0 @@
-import { c as resolveDiscordAccount, d as resolveDiscordAccountDisabledReason, f as resolveDiscordAccountDmPolicy, l as resolveDiscordAccountAllowFrom, n as isDiscordAccountEnabledForRuntime, o as mergeDiscordAccountConfig, r as listDiscordAccountIds, s as resolveDefaultDiscordAccountId } from "./accounts-CwJQoLjM.js";
-import { t as inspectDiscordAccount } from "./account-inspect-BY-ve3yH.js";
-import { t as discordIngressIdentity } from "./ingress-identity-BCzfPPYM.js";
-import { t as DiscordChannelConfigSchema } from "./config-schema-B797-Spt.js";
-import { n as normalizeCompatibilityConfig } from "./doctor-contract-Co5vRCZ6.js";
-import { r as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-DFu9hfU8.js";
-import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DSHk7I2w.js";
-import { t as deriveLegacySessionChatType } from "./session-contract-BO5tlIdl.js";
-import { describeAccountSnapshot } from "openclaw/plugin-sdk/account-helpers";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "openclaw/plugin-sdk/channel-config-helpers";
-import { PAIRING_APPROVED_MESSAGE, buildTokenChannelStatusSummary, projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses as resolveConfiguredFromCredentialStatuses$1 } from "openclaw/plugin-sdk/channel-status";
-import { formatAllowFromLowercase } from "openclaw/plugin-sdk/allow-from";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { createConditionalWarningCollector, createOpenProviderConfiguredRouteWarningCollector } from "openclaw/plugin-sdk/channel-policy";
-import { identityEntryAuthenticationClassifier } from "openclaw/plugin-sdk/channel-ingress-runtime";
-import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { createEnvPatchedAccountSetupAdapter } from "openclaw/plugin-sdk/setup-runtime";
-//#region extensions/discord/src/channel-api.ts
-const DISCORD_CHANNEL_META = {
-	id: "discord",
-	label: "Discord",
-	selectionLabel: "Discord (Bot API)",
-	detailLabel: "Discord Bot",
-	docsPath: "/channels/discord",
-	docsLabel: "discord",
-	blurb: "very well supported right now.",
-	systemImage: "bubble.left.and.bubble.right",
-	markdownCapable: true,
-	preferSessionLookupForAnnounceTarget: true
-};
-function getChatChannelMeta(id) {
-	if (id !== DISCORD_CHANNEL_META.id) throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
-	return DISCORD_CHANNEL_META;
-}
-//#endregion
-//#region extensions/discord/src/security.ts
-const resolveDiscordDmPolicy = createScopedDmSecurityResolver({
-	channelKey: "discord",
-	resolvePolicy: (account) => account.config.dmPolicy,
-	resolveAllowFrom: (account) => account.config.allowFrom,
-	resolveAccess: ({ cfg, account }) => ({
-		dmPolicy: resolveDiscordAccountDmPolicy({
-			cfg,
-			accountId: account.accountId
-		}),
-		allowFrom: resolveDiscordAccountAllowFrom({
-			cfg,
-			accountId: account.accountId
-		})
-	}),
-	policyPathSuffix: "dmPolicy",
-	classifyEntryAuthentication: identityEntryAuthenticationClassifier(discordIngressIdentity),
-	normalizeEntry: (raw) => raw.trim().replace(/^(discord|user):/i, "").replace(/^<@!?(\d+)>$/, "$1")
-});
-const collectDiscordSecurityWarnings = createOpenProviderConfiguredRouteWarningCollector({
-	providerConfigPresent: (cfg) => cfg.channels?.discord !== void 0,
-	resolveGroupPolicy: (account) => account.config.groupPolicy,
-	resolveRouteAllowlistConfigured: (account) => Object.keys(account.config.guilds ?? {}).length > 0,
-	configureRouteAllowlist: {
-		surface: "Discord guilds",
-		openScope: "any channel not explicitly denied",
-		groupPolicyPath: "channels.discord.groupPolicy",
-		routeAllowlistPath: "channels.discord.guilds.<id>.channels"
-	},
-	missingRouteAllowlist: {
-		surface: "Discord guilds",
-		openBehavior: "with no guild/channel allowlist; any channel can trigger (mention-gated)",
-		remediation: "Set channels.discord.groupPolicy=\"allowlist\" and configure channels.discord.guilds.<id>.channels"
-	}
-});
-const collectDiscordSecurityFindings = createConditionalWarningCollector.findings({
-	collectWarnings: collectDiscordSecurityWarnings,
-	checkId: "channels.discord.groups.open",
-	severity: "critical",
-	title: "Discord security warning"
-});
-const loadDiscordSecurityAuditModule = createLazyRuntimeModule(() => import("./security-audit.runtime-sKZyKgpx.js"));
-const discordSecurityAdapter = {
-	resolveDmPolicy: resolveDiscordDmPolicy,
-	collectWarnings: collectDiscordSecurityFindings,
-	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
-};
-//#endregion
-//#region extensions/discord/src/setup-adapter.ts
-const discordSetupAdapter = createEnvPatchedAccountSetupAdapter({
-	channelKey: "discord",
-	defaultAccountOnlyEnvError: "DISCORD_BOT_TOKEN can only be used for the default account.",
-	missingCredentialError: "Discord requires token (or --use-env).",
-	hasCredentials: (input) => Boolean(input.token),
-	buildPatch: (input) => input.token ? { token: input.token } : {}
-});
-const discordSetupContract = defineChannelSetupContract({
-	fields: {
-		token: {
-			kind: "string",
-			sensitive: true,
-			cli: {
-				flags: "--token <token>",
-				description: "Discord bot token"
-			}
-		},
-		useEnv: {
-			kind: "boolean",
-			cli: {
-				flags: "--use-env",
-				description: "Use DISCORD_BOT_TOKEN"
-			},
-			envVars: ["DISCORD_BOT_TOKEN"]
-		}
-	},
-	legacyAdapter: discordSetupAdapter
-});
-//#endregion
-//#region extensions/discord/src/doctor-shared.ts
-const DISCORD_LEGACY_CONFIG_RULES = [];
-//#endregion
-//#region extensions/discord/src/shared.ts
-const DISCORD_CHANNEL = "discord";
-const loadDiscordDoctorModule = createLazyRuntimeModule(() => import("./doctor-QQTOkBfW.js"));
-const discordDoctor = {
-	dmAllowFromMode: "topOnly",
-	groupModel: "route",
-	groupAllowFromFallbackToAllowFrom: false,
-	warnOnEmptyGroupSenderAllowlist: false,
-	legacyConfigRules: DISCORD_LEGACY_CONFIG_RULES,
-	normalizeCompatibilityConfig,
-	collectPreviewWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectPreviewWarnings?.(params) ?? [],
-	collectMutableAllowlistWarnings: async (params) => (await loadDiscordDoctorModule()).discordDoctor.collectMutableAllowlistWarnings?.(params) ?? [],
-	repairConfig: async (params) => (await loadDiscordDoctorModule()).discordDoctor.repairConfig?.(params) ?? {
-		config: params.cfg,
-		changes: []
-	}
-};
-function resolveDiscordConfigAccessorAccount(params) {
-	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultDiscordAccountId(params.cfg));
-	const config = mergeDiscordAccountConfig(params.cfg, accountId);
-	return {
-		allowFrom: resolveDiscordAccountAllowFrom({
-			cfg: params.cfg,
-			accountId
-		}),
-		defaultTo: config.defaultTo
-	};
-}
-const discordConfigAdapter = createScopedChannelConfigAdapter({
-	sectionKey: DISCORD_CHANNEL,
-	listAccountIds: listDiscordAccountIds,
-	resolveAccount: adaptScopedAccountAccessor(resolveDiscordAccount),
-	resolveAccessorAccount: resolveDiscordConfigAccessorAccount,
-	inspectAccount: adaptScopedAccountAccessor(inspectDiscordAccount),
-	defaultAccountId: resolveDefaultDiscordAccountId,
-	clearBaseFields: ["token", "name"],
-	resolveAllowFrom: (account) => account.allowFrom,
-	formatAllowFrom: (allowFrom) => formatAllowFromLowercase({ allowFrom }),
-	resolveDefaultTo: (account) => account.defaultTo
-});
-function createDiscordPluginBase(params) {
-	return {
-		id: DISCORD_CHANNEL,
-		setupContract: params.setupContract,
-		...params.setupWizard ? { setupWizard: params.setupWizard } : {},
-		meta: { ...getChatChannelMeta(DISCORD_CHANNEL) },
-		capabilities: {
-			chatTypes: [
-				"direct",
-				"channel",
-				"thread"
-			],
-			polls: true,
-			reactions: true,
-			threads: true,
-			media: true,
-			tts: { voice: { synthesisTarget: "voice-note" } },
-			nativeCommands: true
-		},
-		commands: {
-			nativeCommandsAutoEnabled: true,
-			nativeSkillsAutoEnabled: true,
-			resolveNativeCommandName: ({ commandKey, defaultName }) => commandKey === "tts" ? "voice" : defaultName
-		},
-		doctor: discordDoctor,
-		streaming: { blockStreamingCoalesceDefaults: {
-			minChars: 1500,
-			idleMs: 1e3
-		} },
-		reload: { configPrefixes: ["channels.discord"] },
-		configSchema: DiscordChannelConfigSchema,
-		config: {
-			...discordConfigAdapter,
-			hasConfiguredState: ({ env }) => typeof env?.DISCORD_BOT_TOKEN === "string" && env.DISCORD_BOT_TOKEN.trim().length > 0,
-			isEnabled: (account, cfg) => isDiscordAccountEnabledForRuntime(account, cfg),
-			disabledReason: (account, cfg) => resolveDiscordAccountDisabledReason(account, cfg),
-			isConfigured: (account) => resolveConfiguredFromCredentialStatuses$1(account) ?? Boolean(account.token?.trim()),
-			describeAccount: (account) => describeAccountSnapshot({
-				account,
-				configured: resolveConfiguredFromCredentialStatuses$1(account) ?? Boolean(account.token?.trim()),
-				extra: {
-					tokenSource: account.tokenSource,
-					tokenStatus: account.tokenStatus
-				}
-			})
-		},
-		messaging: { deriveLegacySessionChatType },
-		security: discordSecurityAdapter,
-		secrets: {
-			secretTargetRegistryEntries,
-			unsupportedSecretRefSurfacePatterns,
-			collectUnsupportedSecretRefConfigCandidates,
-			collectRuntimeConfigAssignments
-		}
-	};
-}
-//#endregion
-export { discordSecurityAdapter as a, buildTokenChannelStatusSummary as c, discordSetupContract as i, projectCredentialSnapshotFields as l, discordConfigAdapter as n, DEFAULT_ACCOUNT_ID$1 as o, DISCORD_LEGACY_CONFIG_RULES as r, PAIRING_APPROVED_MESSAGE as s, createDiscordPluginBase as t, resolveConfiguredFromCredentialStatuses$1 as u };

package/dist/subagent-hooks-IeZVPLGj.js

@@ -1,49 +0,0 @@
-import { on as __exportAll } from "./retry-t5RcEsPk.js";
-import { o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-wECUSIIG.js";
-import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/discord/src/subagent-hooks.ts
-var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
-	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
-	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded
-});
-function normalizeThreadBindingTargetKind(raw) {
-	const normalized = normalizeOptionalLowercaseString(raw);
-	if (normalized === "subagent" || normalized === "acp") return normalized;
-}
-function handleDiscordSubagentEnded(event) {
-	unbindThreadBindingsBySessionKey({
-		targetSessionKey: event.targetSessionKey,
-		accountId: event.accountId,
-		targetKind: normalizeThreadBindingTargetKind(event.targetKind),
-		reason: event.reason,
-		sendFarewell: event.sendFarewell
-	});
-}
-function handleDiscordSubagentDeliveryTarget(event) {
-	if (!event.expectsCompletionMessage) return;
-	if (normalizeOptionalLowercaseString(event.requesterOrigin?.channel) !== "discord") return;
-	const requesterAccountId = event.requesterOrigin?.accountId?.trim();
-	const requesterThreadId = event.requesterOrigin?.threadId != null && event.requesterOrigin.threadId !== "" ? normalizeOptionalStringifiedId(event.requesterOrigin.threadId) ?? "" : "";
-	const bindings = listThreadBindingsBySessionKey({
-		targetSessionKey: event.childSessionKey,
-		...requesterAccountId ? { accountId: requesterAccountId } : {},
-		targetKind: "subagent"
-	});
-	if (bindings.length === 0) return;
-	let binding;
-	if (requesterThreadId) binding = bindings.find((entry) => {
-		if (entry.threadId !== requesterThreadId) return false;
-		if (requesterAccountId && entry.accountId !== requesterAccountId) return false;
-		return true;
-	});
-	if (!binding && bindings.length === 1) binding = bindings[0];
-	if (!binding) return;
-	return { origin: {
-		channel: "discord",
-		accountId: binding.accountId,
-		to: `channel:${binding.threadId}`,
-		threadId: binding.threadId
-	} };
-}
-//#endregion
-export { handleDiscordSubagentEnded as n, subagent_hooks_exports as r, handleDiscordSubagentDeliveryTarget as t };

package/dist/system-events-Be5EJI3b.js

@@ -1,34 +0,0 @@
-import { y as discord_exports } from "./retry-t5RcEsPk.js";
-import { x as formatDiscordUserTag } from "./allow-list-C2JuH-R0.js";
-//#region extensions/discord/src/monitor/system-events.ts
-function resolveDiscordSystemEvent(message, location) {
-	switch (message.type) {
-		case discord_exports.MessageType.ChannelPinnedMessage: return buildDiscordSystemEvent(message, location, "pinned a message");
-		case discord_exports.MessageType.RecipientAdd: return buildDiscordSystemEvent(message, location, "added a recipient");
-		case discord_exports.MessageType.RecipientRemove: return buildDiscordSystemEvent(message, location, "removed a recipient");
-		case discord_exports.MessageType.UserJoin: return buildDiscordSystemEvent(message, location, "user joined");
-		case discord_exports.MessageType.GuildBoost: return buildDiscordSystemEvent(message, location, "boosted the server");
-		case discord_exports.MessageType.GuildBoostTier1: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 1 reached)");
-		case discord_exports.MessageType.GuildBoostTier2: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 2 reached)");
-		case discord_exports.MessageType.GuildBoostTier3: return buildDiscordSystemEvent(message, location, "boosted the server (Tier 3 reached)");
-		case discord_exports.MessageType.ThreadCreated: return buildDiscordSystemEvent(message, location, "created a thread");
-		case discord_exports.MessageType.AutoModerationAction: return buildDiscordSystemEvent(message, location, "auto moderation action");
-		case discord_exports.MessageType.GuildIncidentAlertModeEnabled: return buildDiscordSystemEvent(message, location, "raid protection enabled");
-		case discord_exports.MessageType.GuildIncidentAlertModeDisabled: return buildDiscordSystemEvent(message, location, "raid protection disabled");
-		case discord_exports.MessageType.GuildIncidentReportRaid: return buildDiscordSystemEvent(message, location, "raid reported");
-		case discord_exports.MessageType.GuildIncidentReportFalseAlarm: return buildDiscordSystemEvent(message, location, "raid report marked false alarm");
-		case discord_exports.MessageType.StageStart: return buildDiscordSystemEvent(message, location, "stage started");
-		case discord_exports.MessageType.StageEnd: return buildDiscordSystemEvent(message, location, "stage ended");
-		case discord_exports.MessageType.StageSpeaker: return buildDiscordSystemEvent(message, location, "stage speaker updated");
-		case discord_exports.MessageType.StageTopic: return buildDiscordSystemEvent(message, location, "stage topic updated");
-		case discord_exports.MessageType.PollResult: return buildDiscordSystemEvent(message, location, "poll results posted");
-		case discord_exports.MessageType.PurchaseNotification: return buildDiscordSystemEvent(message, location, "purchase notification");
-		default: return null;
-	}
-}
-function buildDiscordSystemEvent(message, location, action) {
-	const authorLabel = message.author ? formatDiscordUserTag(message.author) : "";
-	return `Discord system: ${authorLabel ? `${authorLabel} ` : ""}${action} in ${location}`;
-}
-//#endregion
-export { resolveDiscordSystemEvent };

package/dist/target-resolver-C0MnwEki.js

@@ -1,83 +0,0 @@
-import { _ as parseDiscordTarget, on as __exportAll, p as allowFromContainsDiscordUserId } from "./retry-t5RcEsPk.js";
-import { c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-CwJQoLjM.js";
-import { a as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-D_kFz_Fj.js";
-import { buildMessagingTarget } from "openclaw/plugin-sdk/channel-targets";
-//#region extensions/discord/src/send-target-parsing.ts
-const parseDiscordSendTarget = (raw, options = {}) => parseDiscordTarget(raw, options);
-//#endregion
-//#region extensions/discord/src/target-resolver.ts
-var target_resolver_exports = /* @__PURE__ */ __exportAll({
-	parseAndResolveDiscordTarget: () => parseAndResolveDiscordTarget,
-	resolveDiscordTarget: () => resolveDiscordTarget
-});
-/**
-* Resolve a Discord username to user ID using the directory lookup.
-* This enables sending DMs by username instead of requiring explicit user IDs.
-*/
-async function resolveDiscordTarget(raw, options, parseOptions = {}) {
-	const trimmed = raw.trim();
-	if (!trimmed) return;
-	const likelyUsername = isLikelyUsername(trimmed);
-	const shouldLookup = isExplicitUserLookup(trimmed, parseOptions) || likelyUsername;
-	if (/^\d+$/.test(trimmed) && parseOptions.defaultKind !== "user" && isConfiguredAllowedDiscordDmUser(trimmed, options)) return buildMessagingTarget("user", trimmed, trimmed);
-	const directParse = safeParseDiscordTarget(trimmed, parseOptions);
-	if (directParse && directParse.kind !== "channel" && !likelyUsername) return directParse;
-	if (!shouldLookup) return directParse ?? parseDiscordSendTarget(trimmed, parseOptions);
-	try {
-		const match = (await listDiscordDirectoryPeersLive({
-			...options,
-			query: trimmed,
-			limit: 1
-		}))[0];
-		if (match && match.kind === "user") {
-			const userId = match.id.replace(/^user:/, "");
-			const resolvedAccountId = resolveDiscordAccount({
-				cfg: options.cfg,
-				accountId: options.accountId
-			}).accountId;
-			rememberDiscordDirectoryUser({
-				accountId: resolvedAccountId,
-				userId,
-				handles: [
-					trimmed,
-					match.name,
-					match.handle
-				]
-			});
-			return buildMessagingTarget("user", userId, trimmed);
-		}
-	} catch {}
-	return parseDiscordSendTarget(trimmed, parseOptions);
-}
-async function parseAndResolveDiscordTarget(raw, options, parseOptions = {}) {
-	const resolved = await resolveDiscordTarget(raw, options, parseOptions) ?? parseDiscordSendTarget(raw, parseOptions);
-	if (!resolved) throw new Error("Recipient is required for Discord sends");
-	return resolved;
-}
-function safeParseDiscordTarget(input, options) {
-	try {
-		return parseDiscordSendTarget(input, options);
-	} catch {
-		return;
-	}
-}
-function isConfiguredAllowedDiscordDmUser(input, options) {
-	const allowFrom = resolveDiscordAccountAllowFrom({
-		cfg: options.cfg,
-		accountId: options.accountId
-	}) ?? [];
-	return allowFromContainsDiscordUserId(allowFrom, input);
-}
-function isExplicitUserLookup(input, options) {
-	if (/^<@!?(\d+)>$/.test(input)) return true;
-	if (/^(user:|discord:)/.test(input)) return true;
-	if (input.startsWith("@")) return true;
-	if (/^\d+$/.test(input)) return options.defaultKind === "user";
-	return false;
-}
-function isLikelyUsername(input) {
-	if (/^(user:|channel:|discord:|@|<@!?)|[\d]+$/.test(input)) return false;
-	return true;
-}
-//#endregion
-export { parseDiscordSendTarget as i, resolveDiscordTarget as n, target_resolver_exports as r, parseAndResolveDiscordTarget as t };

package/dist/targets-DQSye1Rv.js

@@ -1,3 +0,0 @@
-import "./retry-t5RcEsPk.js";
-import "./target-resolver-C0MnwEki.js";
-export {};

package/dist/thread-bindings-wECUSIIG.js

@@ -1,238 +0,0 @@
-import { _ as parseDiscordTarget, on as __exportAll } from "./retry-t5RcEsPk.js";
-import "./targets-DQSye1Rv.js";
-import { C as resolveThreadBindingMaxAgeExpiresAt, O as shouldPersistBindingMutations, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, h as refreshUnboundThreadWebhookIdentity, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-D8OMdk4O.js";
-import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-CC7HoQvt.js";
-import { _ as resolveThreadBindingThreadName, g as resolveThreadBindingIntroText, h as formatThreadBindingDurationLabel, m as resolveThreadBindingPersonaFromRecord, n as createThreadBindingManager, o as resolveChannelIdForBinding, p as resolveThreadBindingPersona, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-B-3UHCc1.js";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import { normalizeOptionalLowercaseString, normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
-import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-runtime";
-import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
-//#region extensions/discord/src/monitor/thread-bindings.config.ts
-function resolveDiscordThreadBindingIdleTimeoutMs(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const root = params.cfg.channels?.discord?.threadBindings;
-	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-	return resolveThreadBindingIdleTimeoutMs({
-		channelIdleHoursRaw: account?.idleHours ?? root?.idleHours,
-		sessionIdleHoursRaw: params.cfg.session?.threadBindings?.idleHours
-	});
-}
-function resolveDiscordThreadBindingMaxAgeMs(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const root = params.cfg.channels?.discord?.threadBindings;
-	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-	return resolveThreadBindingMaxAgeMs({
-		channelMaxAgeHoursRaw: account?.maxAgeHours ?? root?.maxAgeHours,
-		sessionMaxAgeHoursRaw: params.cfg.session?.threadBindings?.maxAgeHours
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/thread-bindings.lifecycle.ts
-const ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT = 8;
-function listThreadBindingsForAccount(accountId) {
-	const manager = getThreadBindingManager(accountId);
-	if (!manager) return [];
-	return manager.listBindings();
-}
-function listThreadBindingsBySessionKey(params) {
-	return resolveBindingIdsForTargetSession(params).map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey)).filter((entry) => Boolean(entry));
-}
-async function autoBindSpawnedDiscordSubagent(params) {
-	if (normalizeOptionalLowercaseString(params.channel) !== "discord") return null;
-	const manager = getThreadBindingManager(params.accountId);
-	if (!manager) return null;
-	const managerToken = getThreadBindingToken(manager.accountId);
-	const requesterThreadId = normalizeThreadId(params.threadId);
-	let channelId = "";
-	if (requesterThreadId) {
-		const existing = manager.getByThreadId(requesterThreadId);
-		if (existing?.channelId?.trim()) channelId = existing.channelId.trim();
-		else channelId = await resolveChannelIdForBinding({
-			cfg: params.cfg,
-			accountId: manager.accountId,
-			token: managerToken,
-			threadId: requesterThreadId
-		}) ?? "";
-	}
-	if (!channelId) {
-		const to = normalizeOptionalString(params.to) ?? "";
-		if (!to) return null;
-		try {
-			const target = parseDiscordTarget(to, { defaultKind: "channel" });
-			if (!target || target.kind !== "channel") return null;
-			channelId = await resolveChannelIdForBinding({
-				cfg: params.cfg,
-				accountId: manager.accountId,
-				token: managerToken,
-				threadId: target.id
-			}) ?? "";
-		} catch {
-			return null;
-		}
-	}
-	return await manager.bindTarget({
-		threadId: void 0,
-		channelId,
-		createThread: true,
-		threadName: resolveThreadBindingThreadName({
-			agentId: params.agentId,
-			label: params.label
-		}),
-		targetKind: "subagent",
-		targetSessionKey: params.childSessionKey,
-		agentId: params.agentId,
-		label: params.label,
-		boundBy: params.boundBy ?? "system",
-		introText: resolveThreadBindingIntroText({
-			agentId: params.agentId,
-			label: params.label,
-			idleTimeoutMs: manager.getIdleTimeoutMs(),
-			maxAgeMs: manager.getMaxAgeMs()
-		})
-	});
-}
-function unbindThreadBindingsBySessionKey(params) {
-	const ids = resolveBindingIdsForTargetSession(params);
-	if (ids.length === 0) return [];
-	const removed = [];
-	for (const bindingKey of ids) {
-		const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
-		if (!record) continue;
-		const manager = MANAGERS_BY_ACCOUNT_ID.get(record.accountId);
-		if (manager) {
-			const unbound = manager.unbindThread({
-				threadId: record.threadId,
-				reason: params.reason,
-				sendFarewell: params.sendFarewell,
-				farewellText: params.farewellText
-			});
-			if (unbound) removed.push(unbound);
-			continue;
-		}
-		const unbound = removeBindingRecord(bindingKey);
-		if (unbound) {
-			refreshUnboundThreadWebhookIdentity(unbound);
-			removed.push(unbound);
-		}
-	}
-	if (removed.length > 0 && shouldPersistBindingMutations()) saveBindingsToDisk({ force: true });
-	return removed;
-}
-function resolveStoredAcpBindingHealth(params) {
-	if (!params.session.acp) return "stale";
-	return "healthy";
-}
-async function reconcileAcpThreadBindingsOnStartup(params) {
-	const manager = getThreadBindingManager(params.accountId);
-	if (!manager) return {
-		checked: 0,
-		removed: 0,
-		staleSessionKeys: []
-	};
-	const acpBindings = manager.listBindings().filter((binding) => binding.targetKind === "acp" && binding.metadata?.pluginBindingOwner !== "plugin");
-	const staleBindings = [];
-	const probeTargets = [];
-	for (const binding of acpBindings) {
-		const sessionKey = binding.targetSessionKey.trim();
-		if (!sessionKey) {
-			staleBindings.push(binding);
-			continue;
-		}
-		const session = readAcpSessionEntry({
-			cfg: params.cfg,
-			sessionKey,
-			agentId: binding.agentId
-		});
-		if (!session) {
-			staleBindings.push(binding);
-			continue;
-		}
-		if (session.storeReadFailed) continue;
-		if (resolveStoredAcpBindingHealth({ session }) === "stale") {
-			staleBindings.push(binding);
-			continue;
-		}
-		if (!params.healthProbe) continue;
-		probeTargets.push({
-			binding,
-			sessionKey,
-			session
-		});
-	}
-	if (params.healthProbe && probeTargets.length > 0) {
-		const { results: probeResults } = await runTasksWithConcurrency({
-			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
-				try {
-					return {
-						binding,
-						status: (await params.healthProbe?.({
-							cfg: params.cfg,
-							accountId: manager.accountId,
-							sessionKey,
-							binding,
-							session
-						}))?.status ?? "uncertain"
-					};
-				} catch {
-					return {
-						binding,
-						status: "uncertain"
-					};
-				}
-			}),
-			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
-			errorMode: "stop",
-			throwOnError: true
-		});
-		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
-	}
-	if (staleBindings.length === 0) return {
-		checked: acpBindings.length,
-		removed: 0,
-		staleSessionKeys: []
-	};
-	const staleSessionKeys = [];
-	let removed = 0;
-	for (const binding of staleBindings) {
-		staleSessionKeys.push(binding.targetSessionKey);
-		if (manager.unbindThread({
-			threadId: binding.threadId,
-			reason: "stale-session",
-			sendFarewell: params.sendFarewell ?? false
-		})) removed += 1;
-	}
-	return {
-		checked: acpBindings.length,
-		removed,
-		staleSessionKeys: uniqueStrings(staleSessionKeys)
-	};
-}
-//#endregion
-//#region extensions/discord/src/monitor/thread-bindings.ts
-var thread_bindings_exports = /* @__PURE__ */ __exportAll({
-	autoBindSpawnedDiscordSubagent: () => autoBindSpawnedDiscordSubagent,
-	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
-	createThreadBindingManager: () => createThreadBindingManager,
-	formatThreadBindingDurationLabel: () => formatThreadBindingDurationLabel,
-	getThreadBindingManager: () => getThreadBindingManager,
-	listThreadBindingsBySessionKey: () => listThreadBindingsBySessionKey,
-	listThreadBindingsForAccount: () => listThreadBindingsForAccount,
-	reconcileAcpThreadBindingsOnStartup: () => reconcileAcpThreadBindingsOnStartup,
-	resolveDiscordThreadBindingIdleTimeoutMs: () => resolveDiscordThreadBindingIdleTimeoutMs,
-	resolveDiscordThreadBindingMaxAgeMs: () => resolveDiscordThreadBindingMaxAgeMs,
-	resolveThreadBindingIdleTimeoutMs: () => resolveThreadBindingIdleTimeoutMs$1,
-	resolveThreadBindingInactivityExpiresAt: () => resolveThreadBindingInactivityExpiresAt,
-	resolveThreadBindingIntroText: () => resolveThreadBindingIntroText,
-	resolveThreadBindingMaxAgeExpiresAt: () => resolveThreadBindingMaxAgeExpiresAt,
-	resolveThreadBindingMaxAgeMs: () => resolveThreadBindingMaxAgeMs$1,
-	resolveThreadBindingPersona: () => resolveThreadBindingPersona,
-	resolveThreadBindingPersonaFromRecord: () => resolveThreadBindingPersonaFromRecord,
-	resolveThreadBindingThreadName: () => resolveThreadBindingThreadName,
-	resolveThreadBindingsEnabled: () => resolveThreadBindingsEnabled,
-	setThreadBindingIdleTimeoutBySessionKey: () => setThreadBindingIdleTimeoutBySessionKey,
-	setThreadBindingMaxAgeBySessionKey: () => setThreadBindingMaxAgeBySessionKey,
-	unbindThreadBindingsBySessionKey: () => unbindThreadBindingsBySessionKey
-});
-//#endregion
-export { reconcileAcpThreadBindingsOnStartup as a, resolveDiscordThreadBindingMaxAgeMs as c, listThreadBindingsForAccount as i, resolveThreadBindingsEnabled as l, autoBindSpawnedDiscordSubagent as n, unbindThreadBindingsBySessionKey as o, listThreadBindingsBySessionKey as r, resolveDiscordThreadBindingIdleTimeoutMs as s, thread_bindings_exports as t };