@kodelyth/discord 2026.5.39 → 2026.6.1

package/dist/sender-identity-CxCe3_1a.js

@@ -0,0 +1,43 @@
+import { b as formatDiscordUserTag } from "./allow-list-B0s7evD7.js";
+import { normalizeOptionalString } from "klaw/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/session-contract-Dwhw3RTY.js

@@ -0,0 +1,6 @@
+//#region extensions/discord/src/session-contract.ts
+function deriveLegacySessionChatType(sessionKey) {
+	return /^discord:(?:[^:]+:)?guild-[^:]+:channel-[^:]+$/.test(sessionKey) ? "channel" : void 0;
+}
+//#endregion
+export { deriveLegacySessionChatType as t };

package/dist/session-key-api.js

@@ -0,0 +1,2 @@
+import { t as normalizeExplicitDiscordSessionKey } from "./session-key-normalization-CP8dPUid.js";
+export { normalizeExplicitDiscordSessionKey };

package/dist/session-key-normalization-CP8dPUid.js

@@ -0,0 +1,23 @@
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/discord/src/session-key-normalization.ts
+function normalizeDiscordChatType(raw) {
+	const normalized = normalizeLowercaseStringOrEmpty(raw);
+	if (!normalized) return;
+	if (normalized === "dm") return "direct";
+	if (normalized === "group" || normalized === "channel" || normalized === "direct") return normalized;
+}
+function normalizeExplicitDiscordSessionKey(sessionKey, ctx) {
+	let normalized = normalizeLowercaseStringOrEmpty(sessionKey);
+	if (normalizeDiscordChatType(ctx.ChatType) !== "direct") return normalized;
+	normalized = normalized.replace(/^(discord:)dm:/, "$1direct:");
+	normalized = normalized.replace(/^(agent:[^:]+:discord:)dm:/, "$1direct:");
+	const match = normalized.match(/^((?:agent:[^:]+:)?)discord:channel:([^:]+)$/);
+	if (!match) return normalized;
+	const from = normalizeLowercaseStringOrEmpty(ctx.From);
+	const senderId = normalizeLowercaseStringOrEmpty(ctx.SenderId);
+	const fromDiscordId = from.startsWith("discord:") && !from.includes(":channel:") && !from.includes(":group:") ? from.slice(8) : "";
+	const directId = senderId || fromDiscordId;
+	return directId && directId === match[2] ? `${match[1]}discord:direct:${match[2]}` : normalized;
+}
+//#endregion
+export { normalizeExplicitDiscordSessionKey as t };

package/dist/setup-entry.js

@@ -0,0 +1,11 @@
+import { defineBundledChannelSetupEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/discord/setup-entry.ts
+var setup_entry_default = defineBundledChannelSetupEntry({
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./setup-plugin-api.js",
+		exportName: "discordSetupPlugin"
+	}
+});
+//#endregion
+export { setup_entry_default as default };

package/dist/setup-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as discordSetupPlugin } from "./channel.setup-BUSC0apv.js";
+export { discordSetupPlugin };

package/dist/shared-AIlvuZXt.js

@@ -0,0 +1,171 @@
+import { a as mergeDiscordAccountConfig, c as resolveDiscordAccountAllowFrom, d as resolveDiscordAccountDmPolicy, n as isDiscordAccountEnabledForRuntime, o as resolveDefaultDiscordAccountId, r as listDiscordAccountIds, s as resolveDiscordAccount, u as resolveDiscordAccountDisabledReason } from "./accounts-B7OBFePq.js";
+import { t as inspectDiscordAccount } from "./account-inspect-Dqw-enky.js";
+import { i as getChatChannelMeta, o as resolveConfiguredFromCredentialStatuses } from "./channel-api-BfjklLby.js";
+import { t as DiscordChannelConfigSchema } from "./config-schema-DIqJBGwC.js";
+import { n as normalizeCompatibilityConfig } from "./doctor-contract-Btjt6NJD.js";
+import { n as secretTargetRegistryEntries, t as collectRuntimeConfigAssignments } from "./secret-config-contract-B6WW5V88.js";
+import { n as unsupportedSecretRefSurfacePatterns, t as collectUnsupportedSecretRefConfigCandidates } from "./security-contract-DLvYOgLM.js";
+import { t as deriveLegacySessionChatType } from "./session-contract-Dwhw3RTY.js";
+import { normalizeAccountId } from "klaw/plugin-sdk/account-id";
+import { describeAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { adaptScopedAccountAccessor, createScopedChannelConfigAdapter, createScopedDmSecurityResolver } from "klaw/plugin-sdk/channel-config-helpers";
+import { createOpenProviderConfiguredRouteWarningCollector } from "klaw/plugin-sdk/channel-policy";
+import { createEnvPatchedAccountSetupAdapter } from "klaw/plugin-sdk/setup-runtime";
+import { formatAllowFromLowercase } from "klaw/plugin-sdk/allow-from";
+//#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",
+	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"
+	}
+});
+let discordSecurityAuditModulePromise;
+async function loadDiscordSecurityAuditModule() {
+	discordSecurityAuditModulePromise ??= import("./security-audit.runtime-CQSkjNLu.js");
+	return await discordSecurityAuditModulePromise;
+}
+const discordSecurityAdapter = {
+	resolveDmPolicy: resolveDiscordDmPolicy,
+	collectWarnings: collectDiscordSecurityWarnings,
+	collectAuditFindings: async (params) => (await loadDiscordSecurityAuditModule()).collectDiscordSecurityAuditFindings(params)
+};
+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 } : {}
+});
+//#endregion
+//#region extensions/discord/src/doctor-shared.ts
+const DISCORD_LEGACY_CONFIG_RULES = [];
+//#endregion
+//#region extensions/discord/src/shared.ts
+const DISCORD_CHANNEL = "discord";
+let discordDoctorModulePromise;
+async function loadDiscordDoctorModule() {
+	discordDoctorModulePromise ??= import("./doctor-bbKSvGVD.js");
+	return await discordDoctorModulePromise;
+}
+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,
+		...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(account) ?? Boolean(account.token?.trim()),
+			describeAccount: (account) => describeAccountSnapshot({
+				account,
+				configured: resolveConfiguredFromCredentialStatuses(account) ?? Boolean(account.token?.trim()),
+				extra: {
+					tokenSource: account.tokenSource,
+					tokenStatus: account.tokenStatus
+				}
+			})
+		},
+		messaging: { deriveLegacySessionChatType },
+		security: discordSecurityAdapter,
+		secrets: {
+			secretTargetRegistryEntries,
+			unsupportedSecretRefSurfacePatterns,
+			collectUnsupportedSecretRefConfigCandidates,
+			collectRuntimeConfigAssignments
+		},
+		setup: params.setup
+	};
+}
+//#endregion
+export { discordSecurityAdapter as a, discordSetupAdapter as i, discordConfigAdapter as n, DISCORD_LEGACY_CONFIG_RULES as r, createDiscordPluginBase as t };

package/dist/subagent-hooks-8bK-mgiU.js

@@ -0,0 +1,120 @@
+import { Wt as __exportAll } from "./send.receipt-CDn3GBWC.js";
+import { s as resolveDiscordAccount } from "./accounts-B7OBFePq.js";
+import { n as autoBindSpawnedDiscordSubagent, o as unbindThreadBindingsBySessionKey, r as listThreadBindingsBySessionKey } from "./thread-bindings-9aKRmZv0.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalStringifiedId } from "klaw/plugin-sdk/string-coerce-runtime";
+import { formatThreadBindingDisabledError, formatThreadBindingSpawnDisabledError, resolveThreadBindingSpawnPolicy } from "klaw/plugin-sdk/conversation-runtime";
+//#region extensions/discord/src/subagent-hooks.ts
+var subagent_hooks_exports = /* @__PURE__ */ __exportAll({
+	handleDiscordSubagentDeliveryTarget: () => handleDiscordSubagentDeliveryTarget,
+	handleDiscordSubagentEnded: () => handleDiscordSubagentEnded,
+	handleDiscordSubagentSpawning: () => handleDiscordSubagentSpawning
+});
+function summarizeError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	return "error";
+}
+function normalizeThreadBindingTargetKind(raw) {
+	const normalized = normalizeOptionalLowercaseString(raw);
+	if (normalized === "subagent" || normalized === "acp") return normalized;
+}
+async function handleDiscordSubagentSpawning(api, event) {
+	if (!event.threadRequested) return;
+	if (normalizeOptionalLowercaseString(event.requester?.channel) !== "discord") return;
+	const account = resolveDiscordAccount({
+		cfg: api.config,
+		accountId: event.requester?.accountId
+	});
+	const threadBindingPolicy = resolveThreadBindingSpawnPolicy({
+		cfg: api.config,
+		channel: "discord",
+		accountId: account.accountId,
+		kind: "subagent"
+	});
+	if (!threadBindingPolicy.enabled) return {
+		status: "error",
+		error: formatThreadBindingDisabledError({
+			channel: threadBindingPolicy.channel,
+			accountId: threadBindingPolicy.accountId,
+			kind: "subagent"
+		})
+	};
+	if (!threadBindingPolicy.spawnEnabled) return {
+		status: "error",
+		error: formatThreadBindingSpawnDisabledError({
+			channel: threadBindingPolicy.channel,
+			accountId: threadBindingPolicy.accountId,
+			kind: "subagent"
+		})
+	};
+	try {
+		const agentId = event.agentId?.trim() || "subagent";
+		const binding = await autoBindSpawnedDiscordSubagent({
+			cfg: api.config,
+			accountId: account.accountId,
+			channel: event.requester?.channel,
+			to: event.requester?.to,
+			threadId: event.requester?.threadId,
+			childSessionKey: event.childSessionKey,
+			agentId,
+			label: event.label,
+			boundBy: "system"
+		});
+		if (!binding) return {
+			status: "error",
+			error: "Unable to create or bind a Discord thread for this subagent session. Session mode is unavailable for this target."
+		};
+		return {
+			status: "ok",
+			threadBindingReady: true,
+			deliveryOrigin: {
+				channel: "discord",
+				accountId: account.accountId,
+				to: `channel:${binding.threadId}`,
+				threadId: binding.threadId
+			}
+		};
+	} catch (err) {
+		return {
+			status: "error",
+			error: `Discord thread bind failed: ${summarizeError(err)}`
+		};
+	}
+}
+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 { subagent_hooks_exports as i, handleDiscordSubagentEnded as n, handleDiscordSubagentSpawning as r, handleDiscordSubagentDeliveryTarget as t };

package/dist/subagent-hooks-api.js

@@ -0,0 +1,22 @@
+//#region extensions/discord/subagent-hooks-api.ts
+let discordSubagentHooksPromise = null;
+function loadDiscordSubagentHooksModule() {
+	discordSubagentHooksPromise ??= import("./subagent-hooks-8bK-mgiU.js").then((n) => n.i);
+	return discordSubagentHooksPromise;
+}
+function registerDiscordSubagentHooks(api) {
+	api.on("subagent_spawning", async (event) => {
+		const { handleDiscordSubagentSpawning } = await loadDiscordSubagentHooksModule();
+		return await handleDiscordSubagentSpawning(api, event);
+	});
+	api.on("subagent_ended", async (event) => {
+		const { handleDiscordSubagentEnded } = await loadDiscordSubagentHooksModule();
+		handleDiscordSubagentEnded(event);
+	});
+	api.on("subagent_delivery_target", async (event) => {
+		const { handleDiscordSubagentDeliveryTarget } = await loadDiscordSubagentHooksModule();
+		return handleDiscordSubagentDeliveryTarget(event);
+	});
+}
+//#endregion
+export { registerDiscordSubagentHooks };

package/dist/system-events-Ba1TklaL.js

@@ -0,0 +1,34 @@
+import { c as discord_exports } from "./send.receipt-CDn3GBWC.js";
+import { b as formatDiscordUserTag } from "./allow-list-B0s7evD7.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-BrtFQtoK.js

@@ -0,0 +1,82 @@
+import { Ht as parseDiscordTarget, Wt as __exportAll, r as allowFromContainsDiscordUserId } from "./send.receipt-CDn3GBWC.js";
+import { c as resolveDiscordAccountAllowFrom, s as resolveDiscordAccount } from "./accounts-B7OBFePq.js";
+import { i as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-DX4dLRpJ.js";
+import { buildMessagingTarget } from "klaw/plugin-sdk/messaging-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) {
+	return allowFromContainsDiscordUserId(resolveDiscordAccountAllowFrom({
+		cfg: options.cfg,
+		accountId: options.accountId
+	}) ?? [], 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-DWLLZE2l.js

@@ -0,0 +1,3 @@
+import "./send.receipt-CDn3GBWC.js";
+import "./target-resolver-BrtFQtoK.js";
+export {};

package/dist/test-api.js

@@ -0,0 +1,45 @@
+import { t as discordPlugin } from "./channel-U_aeoFwW.js";
+import { n as discordOutbound } from "./outbound-adapter-C18OAc1y.js";
+import { i as testing } from "./thread-bindings.manager-0YBHGemk.js";
+import { n as buildDiscordInboundAccessContext } from "./inbound-context-WAOqhGlT.js";
+import { finalizeInboundContext } from "klaw/plugin-sdk/reply-dispatch-runtime";
+//#region extensions/discord/src/monitor/inbound-context.test-helpers.ts
+function buildFinalizedDiscordDirectInboundContext() {
+	const { groupSystemPrompt, ownerAllowFrom, untrustedContext } = buildDiscordInboundAccessContext({
+		channelConfig: null,
+		guildInfo: null,
+		sender: {
+			id: "U1",
+			name: "Alice",
+			tag: "alice"
+		},
+		isGuild: false
+	});
+	return finalizeInboundContext({
+		Body: "hi",
+		BodyForAgent: "hi",
+		RawBody: "hi",
+		CommandBody: "hi",
+		From: "discord:U1",
+		To: "user:U1",
+		SessionKey: "agent:main:discord:direct:u1",
+		AccountId: "default",
+		ChatType: "direct",
+		ConversationLabel: "Alice",
+		SenderName: "Alice",
+		SenderId: "U1",
+		SenderUsername: "alice",
+		GroupSystemPrompt: groupSystemPrompt,
+		OwnerAllowFrom: ownerAllowFrom,
+		UntrustedStructuredContext: untrustedContext,
+		Provider: "discord",
+		Surface: "discord",
+		WasMentioned: false,
+		MessageSid: "m1",
+		CommandAuthorized: true,
+		OriginatingChannel: "discord",
+		OriginatingTo: "user:U1"
+	});
+}
+//#endregion
+export { buildFinalizedDiscordDirectInboundContext, discordOutbound, discordPlugin, testing as discordThreadBindingTesting };

package/dist/thread-binding-api.js

@@ -0,0 +1,4 @@
+//#region extensions/discord/thread-binding-api.ts
+const defaultTopLevelPlacement = "child";
+//#endregion
+export { defaultTopLevelPlacement };