@kodelyth/discord 2026.5.39 → 2026.5.42

package/dist/thread-bindings-9aKRmZv0.js

@@ -0,0 +1,255 @@
+import { Ht as parseDiscordTarget, Wt as __exportAll } from "./send.receipt-CDn3GBWC.js";
+import "./targets-DWLLZE2l.js";
+import { C as resolveThreadBindingMaxAgeMs$1, O as shouldPersistBindingMutations, S as resolveThreadBindingMaxAgeExpiresAt, T as saveBindingsToDisk, b as resolveThreadBindingIdleTimeoutMs$1, c as getThreadBindingToken, f as normalizeThreadId, g as removeBindingRecord, l as isRecentlyUnboundThreadWebhookMessage, n as MANAGERS_BY_ACCOUNT_ID, p as rememberRecentUnboundWebhookEcho, t as BINDINGS_BY_THREAD_ID, x as resolveThreadBindingInactivityExpiresAt } from "./thread-bindings.state-eTFl-PqJ.js";
+import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-DJZGIwaU.js";
+import { _ as formatThreadBindingDurationLabel, b as resolveThreadBindingThreadName, g as resolveThreadBindingPersonaFromRecord, h as resolveThreadBindingPersona, s as resolveChannelIdForBinding, y as resolveThreadBindingIntroText } from "./thread-bindings.discord-api-ssGH5wc2.js";
+import { i as testing, n as createThreadBindingManager, r as getThreadBindingManager, t as createNoopThreadBindingManager } from "./thread-bindings.manager-0YBHGemk.js";
+import { normalizeOptionalLowercaseString, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { normalizeAccountId } from "klaw/plugin-sdk/routing";
+import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "klaw/plugin-sdk/conversation-runtime";
+import { readAcpSessionEntry } from "klaw/plugin-sdk/acp-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;
+async function mapWithConcurrency(params) {
+	if (params.items.length === 0) return [];
+	const limit = Math.max(1, Math.floor(params.limit));
+	const resultsByIndex = /* @__PURE__ */ new Map();
+	let nextIndex = 0;
+	const runWorker = async () => {
+		for (;;) {
+			const index = nextIndex;
+			nextIndex += 1;
+			if (index >= params.items.length) return;
+			resultsByIndex.set(index, await params.worker(params.items[index], index));
+		}
+	};
+	const workers = Array.from({ length: Math.min(limit, params.items.length) }, () => runWorker());
+	await Promise.all(workers);
+	return params.items.map((_item, index) => resultsByIndex.get(index));
+}
+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) {
+			rememberRecentUnboundWebhookEcho(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
+		});
+		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 probeResults = await mapWithConcurrency({
+			items: probeTargets,
+			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
+			worker: async ({ binding, sessionKey, session }) => {
+				try {
+					return {
+						binding,
+						status: (await params.healthProbe?.({
+							cfg: params.cfg,
+							accountId: manager.accountId,
+							sessionKey,
+							binding,
+							session
+						}))?.status ?? "uncertain"
+					};
+				} catch {
+					return {
+						binding,
+						status: "uncertain"
+					};
+				}
+			}
+		});
+		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: [...new Set(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,
+	isRecentlyUnboundThreadWebhookMessage: () => isRecentlyUnboundThreadWebhookMessage,
+	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,
+	testing: () => testing,
+	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 };

package/dist/thread-bindings.discord-api-ssGH5wc2.js

@@ -0,0 +1,244 @@
+import { Ut as resolveDiscordChannelId, pt as getChannel, tt as createChannelWebhook } from "./send.receipt-CDn3GBWC.js";
+import { N as createDiscordRestClient } from "./send.shared-D4iBnAmn.js";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-DCtPCHGk.js";
+import { t as sendMessageDiscord } from "./send.outbound-S9t0UuHc.js";
+import { i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, k as toReusableWebhookKey, m as rememberReusableWebhook, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-eTFl-PqJ.js";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { ChannelType } from "discord-api-types/v10";
+import { logVerbose } from "klaw/plugin-sdk/runtime-env";
+import { SYSTEM_MARK } from "klaw/plugin-sdk/text-chunking";
+import { formatThreadBindingDurationLabel, resolveThreadBindingFarewellText, resolveThreadBindingIntroText, resolveThreadBindingThreadName } from "klaw/plugin-sdk/conversation-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.persona.ts
+const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
+function normalizePersonaLabel(value) {
+	if (!value) return;
+	return value.replace(/\s+/g, " ").trim() || void 0;
+}
+function resolveThreadBindingPersona(params) {
+	return `${SYSTEM_MARK} ${normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent"}`.slice(0, THREAD_BINDING_PERSONA_MAX_CHARS);
+}
+function resolveThreadBindingPersonaFromRecord(record) {
+	return resolveThreadBindingPersona({
+		label: record.label,
+		agentId: record.agentId
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/channel-access.ts
+function readDiscordChannelPropertySafe(channel, key) {
+	if (!channel || typeof channel !== "object") return;
+	try {
+		if (!(key in channel)) return;
+		return channel[key];
+	} catch {
+		return;
+	}
+}
+function resolveDiscordChannelStringPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "string" ? value : void 0;
+}
+function resolveDiscordChannelNumberPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "number" ? value : void 0;
+}
+const DISCORD_CHANNEL_SNAKE_CASE_ALIASES = {
+	ownerId: "owner_id",
+	parentId: "parent_id"
+};
+function resolveDiscordChannelStringWithAliasSafe(channel, camelKey) {
+	const camelValue = resolveDiscordChannelStringPropertySafe(channel, camelKey);
+	if (camelValue !== void 0) return camelValue;
+	const snakeKey = DISCORD_CHANNEL_SNAKE_CASE_ALIASES[camelKey];
+	if (!snakeKey) return;
+	const directSnakeValue = resolveDiscordChannelStringPropertySafe(channel, snakeKey);
+	if (directSnakeValue !== void 0) return directSnakeValue;
+	return resolveDiscordChannelStringPropertySafe(readDiscordChannelPropertySafe(channel, "rawData"), snakeKey);
+}
+function resolveDiscordChannelNameSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "name");
+}
+function resolveDiscordChannelIdSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "id");
+}
+function resolveDiscordChannelTopicSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "topic");
+}
+function resolveDiscordChannelParentIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "parentId");
+}
+function resolveDiscordChannelOwnerIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "ownerId");
+}
+function resolveDiscordChannelParentSafe(channel) {
+	return readDiscordChannelPropertySafe(channel, "parent");
+}
+function resolveDiscordChannelInfoSafe(channel) {
+	const parent = resolveDiscordChannelParentSafe(channel);
+	return {
+		name: resolveDiscordChannelNameSafe(channel),
+		topic: resolveDiscordChannelTopicSafe(channel),
+		type: resolveDiscordChannelNumberPropertySafe(channel, "type"),
+		parentId: resolveDiscordChannelParentIdSafe(channel),
+		ownerId: resolveDiscordChannelOwnerIdSafe(channel),
+		parentName: resolveDiscordChannelNameSafe(parent)
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.discord-api.ts
+function buildThreadTarget(threadId) {
+	return /^(channel:|user:)/i.test(threadId) ? threadId : `channel:${threadId}`;
+}
+function isThreadArchived(raw) {
+	if (!raw || typeof raw !== "object") return false;
+	const asRecord = raw;
+	if (asRecord.archived === true) return true;
+	if (asRecord.thread_metadata?.archived === true) return true;
+	if (asRecord.threadMetadata?.archived === true) return true;
+	return false;
+}
+function isThreadChannelType(type) {
+	return type === ChannelType.PublicThread || type === ChannelType.PrivateThread || type === ChannelType.AnnouncementThread;
+}
+function normalizeDiscordBindingChannelId(raw) {
+	const trimmed = normalizeOptionalString(raw) ?? "";
+	if (!trimmed) return null;
+	try {
+		return resolveDiscordChannelId(trimmed);
+	} catch {
+		return null;
+	}
+}
+function summarizeDiscordError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint" || typeof err === "symbol") return String(err);
+	return "error";
+}
+function extractNumericDiscordErrorValue(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
+	if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(value);
+}
+function extractDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.status) ?? extractNumericDiscordErrorValue(candidate.statusCode) ?? extractNumericDiscordErrorValue(candidate.response?.status);
+}
+function extractDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.code) ?? extractNumericDiscordErrorValue(candidate.rawError?.code) ?? extractNumericDiscordErrorValue(candidate.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.data?.code);
+}
+function isDiscordThreadGoneError(err) {
+	if (extractDiscordErrorCode(err) === 10003) return true;
+	const status = extractDiscordErrorStatus(err);
+	return status === 404 || status === 403;
+}
+async function maybeSendBindingMessage(params) {
+	const text = params.text.trim();
+	if (!text) return;
+	const record = params.record;
+	if (params.preferWebhook !== false && record.webhookId && record.webhookToken) try {
+		await sendWebhookMessageDiscord(text, {
+			cfg: params.cfg,
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken,
+			accountId: record.accountId,
+			threadId: record.threadId,
+			username: resolveThreadBindingPersonaFromRecord(record)
+		});
+		return;
+	} catch (err) {
+		logVerbose(`discord thread binding webhook send failed: ${summarizeDiscordError(err)}`);
+	}
+	try {
+		await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+			cfg: params.cfg,
+			accountId: record.accountId
+		});
+	} catch (err) {
+		logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
+	}
+}
+async function createWebhookForChannel(params) {
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const created = await createChannelWebhook(rest, params.channelId, { body: { name: "Klaw Agents" } });
+		const webhookId = normalizeOptionalString(created?.id) ?? "";
+		const webhookToken = normalizeOptionalString(created?.token) ?? "";
+		if (!webhookId || !webhookToken) return {};
+		return {
+			webhookId,
+			webhookToken
+		};
+	} catch (err) {
+		logVerbose(`discord thread binding webhook create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return {};
+	}
+}
+function findReusableWebhook(params) {
+	const reusableKey = toReusableWebhookKey({
+		accountId: params.accountId,
+		channelId: params.channelId
+	});
+	const cached = REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.get(reusableKey);
+	if (cached) return {
+		webhookId: cached.webhookId,
+		webhookToken: cached.webhookToken
+	};
+	for (const record of BINDINGS_BY_THREAD_ID.values()) {
+		if (record.accountId !== params.accountId) continue;
+		if (record.channelId !== params.channelId) continue;
+		if (!record.webhookId || !record.webhookToken) continue;
+		rememberReusableWebhook(record);
+		return {
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken
+		};
+	}
+	return {};
+}
+async function resolveChannelIdForBinding(params) {
+	const explicit = normalizeDiscordBindingChannelId(params.channelId);
+	if (explicit) return explicit;
+	const lookupThreadId = normalizeDiscordBindingChannelId(params.threadId);
+	if (!lookupThreadId) return null;
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const channel = await getChannel(rest, lookupThreadId);
+		const channelInfo = resolveDiscordChannelInfoSafe(channel);
+		const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
+		const type = channelInfo.type;
+		const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
+		if (parentId && isThreadChannelType(type)) return parentId;
+		return channelId || null;
+	} catch (err) {
+		logVerbose(`discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+async function createThreadForBinding(params) {
+	try {
+		return (normalizeOptionalString((await createThreadDiscord(params.channelId, {
+			name: params.threadName,
+			autoArchiveMinutes: 60
+		}, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}))?.id) ?? "") || null;
+	} catch (err) {
+		logVerbose(`discord thread binding auto-thread create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+//#endregion
+export { formatThreadBindingDurationLabel as _, isThreadArchived as a, resolveThreadBindingThreadName as b, summarizeDiscordError as c, resolveDiscordChannelNameSafe as d, resolveDiscordChannelParentIdSafe as f, resolveThreadBindingPersonaFromRecord as g, resolveThreadBindingPersona as h, isDiscordThreadGoneError as i, resolveDiscordChannelIdSafe as l, resolveDiscordChannelTopicSafe as m, createWebhookForChannel as n, maybeSendBindingMessage as o, resolveDiscordChannelParentSafe as p, findReusableWebhook as r, resolveChannelIdForBinding as s, createThreadForBinding as t, resolveDiscordChannelInfoSafe as u, resolveThreadBindingFarewellText as v, resolveThreadBindingIntroText as y };