@openclaw/discord 2026.8.1-beta.2 → 2026.8.1

package/dist/{thread-bindings-3L8p82GV.js → thread-bindings-DvYP79fy.js}

@@ -1,13 +1,13 @@
-import { p as parseDiscordTarget, tn as __exportAll } from "./retry-CLpJcXXf.js";
-import "./targets-yUFTHoAx.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-aeV8HNgV.js";
-import { n as setThreadBindingMaxAgeBySessionKey, r as resolveBindingIdsForTargetSession, t as setThreadBindingIdleTimeoutBySessionKey } from "./thread-bindings.session-updates-bJ2KQFY6.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-DCIH6WDC.js";
+import { _ as parseDiscordTarget, on as __exportAll } from "./retry-DqHCW6PV.js";
+import "./targets-CQp53cGj.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-CJb-BpPL.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-Clm77DBM.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 pMap from "p-map";
+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);
@@ -160,27 +160,29 @@ async function reconcileAcpThreadBindingsOnStartup(params) {
 		});
 	}
 	if (params.healthProbe && probeTargets.length > 0) {
-		const probeResults = await pMap(probeTargets, async ({ binding, sessionKey, session }) => {
-			try {
-				return {
-					binding,
-					status: (await params.healthProbe?.({
-						cfg: params.cfg,
-						accountId: manager.accountId,
-						sessionKey,
+		const { results: probeResults } = await runTasksWithConcurrency({
+			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
+				try {
+					return {
 						binding,
-						session
-					}))?.status ?? "uncertain"
-				};
-			} catch {
-				return {
-					binding,
-					status: "uncertain"
-				};
-			}
-		}, {
-			concurrency: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
-			stopOnError: true
+						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);
 	}

package/dist/{thread-bindings.manager-DCIH6WDC.js → thread-bindings.manager-Clm77DBM.js}

@@ -1,18 +1,18 @@
-import { Tt as getChannel, m as resolveDiscordChannelId, pt as createChannelWebhook, tn as __exportAll } from "./retry-CLpJcXXf.js";
-import { F as createDiscordRestClient } from "./send.shared-BmwFjW6T.js";
-import { t as sendMessageDiscord } from "./send.outbound-DS5tHwfR.js";
-import { i as sendWebhookMessageDiscord, o as createThreadDiscord } from "./send-B7Q6Oc1I.js";
-import { A as toReusableWebhookKey, C as resolveThreadBindingMaxAgeExpiresAt, D as shouldDefaultPersist, E as setBindingRecord, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, _ as rememberThreadBindingToken, b as resolveBindingRecordKey, c as ensureBindingsLoaded, f as normalizeTargetKind, g as rememberReusableWebhook, h as refreshUnboundThreadWebhookIdentity, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1, y as resolveBindingIdsForSession } from "./thread-bindings.state-aeV8HNgV.js";
+import { At as getChannel, on as __exportAll, v as resolveDiscordChannelId, vt as createChannelWebhook } from "./retry-DqHCW6PV.js";
+import { P as createDiscordRestClient } from "./send.shared-DZJ1akvQ.js";
+import { t as sendMessageDiscord } from "./send.outbound-D7JYmfm9.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-UJHiAm4C.js";
+import { A as toReusableWebhookKey, C as resolveThreadBindingMaxAgeExpiresAt, D as shouldDefaultPersist, E as setBindingRecord, S as resolveThreadBindingInactivityExpiresAt, T as saveBindingsToDisk, _ as rememberThreadBindingToken, b as resolveBindingRecordKey, c as ensureBindingsLoaded, f as normalizeTargetKind, g as rememberReusableWebhook, h as refreshUnboundThreadWebhookIdentity, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as forgetThreadBindingToken, m as normalizeThreadId, n as MANAGERS_BY_ACCOUNT_ID, p as normalizeThreadBindingDurationMs, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, t as BINDINGS_BY_THREAD_ID, u as getThreadBindingToken, v as removeBindingRecord, w as resolveThreadBindingMaxAgeMs$1, x as resolveThreadBindingIdleTimeoutMs$1, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
-import { ChannelType } from "discord-api-types/v10";
-import { parseStrictNonNegativeInteger as parseStrictNonNegativeInteger$1 } from "openclaw/plugin-sdk/number-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { SYSTEM_MARK } from "openclaw/plugin-sdk/text-chunking";
 import { formatThreadBindingDurationLabel, registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingFarewellText, resolveThreadBindingIntroText, resolveThreadBindingThreadName, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
-import { resolveSessionAgentId } from "openclaw/plugin-sdk/agent-scope-runtime";
+import { resolveSessionAgentIdStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.persona.ts
 const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
 function normalizePersonaLabel(value) {
@@ -106,9 +106,6 @@ function isThreadArchived(raw) {
 	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;
@@ -125,7 +122,7 @@ function summarizeDiscordError(err) {
 	return "error";
 }
 function extractNumericDiscordErrorValue(value) {
-	return parseStrictNonNegativeInteger$1(value);
+	return parseStrictNonNegativeInteger(value);
 }
 function extractDiscordErrorStatus(err) {
 	if (!err || typeof err !== "object") return;
@@ -226,7 +223,7 @@ async function resolveChannelIdForBinding(params) {
 		const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
 		const type = channelInfo.type;
 		const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
-		if (parentId && isThreadChannelType(type)) return parentId;
+		if (parentId && isDiscordThreadChannelType(type)) return parentId;
 		return channelId || null;
 	} catch (err) {
 		logVerbose(`discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`);
@@ -634,7 +631,7 @@ function createThreadBindingManager(params) {
 				threadId,
 				targetKind,
 				targetSessionKey,
-				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveSessionAgentId({
+				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveSessionAgentIdStrict({
 					config: cfg,
 					sessionKey: targetSessionKey
 				}),

package/dist/{thread-bindings.session-updates-bJ2KQFY6.js → thread-bindings.session-updates-CJb-BpPL.js}

@@ -1,4 +1,4 @@
-import { E as setBindingRecord, O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, y as resolveBindingIdsForSession } from "./thread-bindings.state-aeV8HNgV.js";
+import { E as setBindingRecord, O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as ensureBindingsLoaded, t as BINDINGS_BY_THREAD_ID, y as resolveBindingIdsForSession } from "./thread-bindings.state-D8OMdk4O.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
 function normalizeNonNegativeMs(raw) {

package/dist/{thread-bindings.state-aeV8HNgV.js → thread-bindings.state-D8OMdk4O.js}

@@ -223,7 +223,7 @@ function shouldPersistBindingMutations() {
 function toPersistedBindingRecord(record) {
 	const serialized = JSON.stringify(record);
 	if (!serialized) return { ...record };
-	return JSON.parse(serialized);
+	return normalizePersistedBinding(record.threadId, JSON.parse(serialized)) ?? { ...record };
 }
 function saveBindingsToDisk(params = {}) {
 	if (!params.force && !shouldPersistAnyBindingState()) return;

package/dist/threading-CXuu_7o9.js

@@ -0,0 +1,478 @@
+import { F as DiscordError, Ot as editChannel, Tt as createThread, jt as getChannelMessage, on as __exportAll, y as discord_exports } from "./retry-DqHCW6PV.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { d as resolveDiscordChannelParentSafe, l as resolveDiscordChannelNameSafe, s as resolveDiscordChannelIdSafe, u as resolveDiscordChannelParentIdSafe } from "./thread-bindings.manager-Clm77DBM.js";
+import { a as formatDiscordMediaText, f as resolveDiscordChannelInfo, n as resolveDiscordForwardedMessagesTextFromSnapshots, p as resolveDiscordMessageChannelId, t as resolveDiscordEmbedText } from "./message-text-Ca8M6TU8.js";
+import { buildAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { createReplyReferencePlanner } from "openclaw/plugin-sdk/reply-reference";
+import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
+import { resolveChannelModelOverride } from "openclaw/plugin-sdk/model-session-runtime";
+import { generateConversationLabel } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+//#region extensions/discord/src/monitor/thread-title.ts
+const DEFAULT_THREAD_TITLE_TIMEOUT_MS = 6e4;
+const MAX_THREAD_TITLE_SOURCE_CHARS = 600;
+const MAX_THREAD_TITLE_CHANNEL_NAME_CHARS = 120;
+const MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS = 320;
+const DISCORD_THREAD_TITLE_SYSTEM_PROMPT = "Generate a concise Discord thread title (3-6 words) in sentence case: capitalize only the first word and words that are always capitalized. Return only the title. Use channel context when provided and avoid redundant channel-name words unless needed for clarity.";
+async function generateThreadTitle(params) {
+	const sourceText = params.messageText.trim();
+	if (!sourceText) return null;
+	try {
+		const userMessage = buildThreadTitleCompletionUserMessage({
+			sourceText,
+			channelName: params.channelName,
+			channelDescription: params.channelDescription
+		});
+		const timeoutMs = resolveThreadTitleTimeoutMs(params.timeoutMs);
+		const generated = await generateConversationLabel({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			userMessage,
+			prompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+			...params.modelRef ? { modelRef: params.modelRef } : {},
+			timeoutMs,
+			maxLength: MAX_THREAD_TITLE_SOURCE_CHARS
+		});
+		return generated ? normalizeGeneratedThreadTitle(generated) : null;
+	} catch (err) {
+		logVerbose(`thread-title: title generation failed for agent ${params.agentId}: ${String(err)}`);
+		return null;
+	}
+}
+function buildThreadTitleCompletionUserMessage(params) {
+	const sourceText = truncateThreadTitleSourceText(params.sourceText);
+	const channelName = normalizeTitleContextField(params.channelName, MAX_THREAD_TITLE_CHANNEL_NAME_CHARS);
+	const channelDescription = normalizeTitleContextField(params.channelDescription, MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS);
+	const messageLines = [];
+	if (channelName) messageLines.push(`Channel: ${channelName}`);
+	if (channelDescription) messageLines.push(`Channel description: ${channelDescription}`);
+	messageLines.push(`Message:\n${sourceText}`);
+	return messageLines.join("\n\n");
+}
+function truncateThreadTitleSourceText(sourceText) {
+	if (sourceText.length <= MAX_THREAD_TITLE_SOURCE_CHARS) return sourceText;
+	return `${truncateUtf16Safe(sourceText, MAX_THREAD_TITLE_SOURCE_CHARS)}...`;
+}
+function resolveThreadTitleTimeoutMs(timeoutMs) {
+	return Math.max(100, Math.floor(timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS));
+}
+function normalizeGeneratedThreadTitle(raw) {
+	const lines = raw.replace(/\r/g, "").split("\n");
+	let firstLine = "";
+	for (const line of lines) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		if (!firstLine && trimmed.startsWith("```")) continue;
+		firstLine = trimmed;
+		break;
+	}
+	return stripThreadTitleWrappers(firstLine);
+}
+function stripThreadTitleWrappers(raw) {
+	let current = raw.trim();
+	let previous = "";
+	while (current && current !== previous) {
+		previous = current;
+		current = current.replace(/^["'`]+|["'`]+$/g, "").trim();
+		current = stripBalancedWrapper(current, "**");
+		current = stripBalancedWrapper(current, "__");
+		current = stripBalancedWrapper(current, "*");
+		current = stripBalancedWrapper(current, "_");
+		current = stripBalancedWrapper(current, "~~");
+	}
+	return current;
+}
+function stripBalancedWrapper(text, marker) {
+	if (text.length < marker.length * 2 + 1) return text;
+	if (!text.startsWith(marker) || !text.endsWith(marker)) return text;
+	const inner = text.slice(marker.length, text.length - marker.length);
+	if (!inner || inner.includes(marker)) return text;
+	return inner;
+}
+function normalizeTitleContextField(raw, maxChars) {
+	const value = raw?.trim();
+	if (!value) return;
+	const singleLine = value.replace(/\s+/g, " ");
+	if (singleLine.length <= maxChars) return singleLine;
+	return `${truncateUtf16Safe(singleLine, maxChars)}...`;
+}
+//#endregion
+//#region extensions/discord/src/monitor/threading.cache.ts
+const DISCORD_THREAD_STARTER_CACHE_TTL_MS = 300 * 1e3;
+const DISCORD_THREAD_STARTER_NEGATIVE_CACHE_TTL_MS = 30 * 1e3;
+const DISCORD_THREAD_STARTER_CACHE_MAX = 500;
+const DISCORD_THREAD_STARTER_CACHE = /* @__PURE__ */ new Map();
+function getCachedThreadStarter(key, now) {
+	const entry = DISCORD_THREAD_STARTER_CACHE.get(key);
+	if (!entry) return;
+	const ttlMs = entry.value.kind === "miss" ? DISCORD_THREAD_STARTER_NEGATIVE_CACHE_TTL_MS : DISCORD_THREAD_STARTER_CACHE_TTL_MS;
+	if (now < entry.updatedAt || now - entry.updatedAt >= ttlMs) {
+		DISCORD_THREAD_STARTER_CACHE.delete(key);
+		return;
+	}
+	DISCORD_THREAD_STARTER_CACHE.delete(key);
+	DISCORD_THREAD_STARTER_CACHE.set(key, entry);
+	return entry.value;
+}
+function setCachedThreadStarter(key, value, now) {
+	DISCORD_THREAD_STARTER_CACHE.delete(key);
+	DISCORD_THREAD_STARTER_CACHE.set(key, {
+		value,
+		updatedAt: now
+	});
+	pruneMapToMaxSize(DISCORD_THREAD_STARTER_CACHE, DISCORD_THREAD_STARTER_CACHE_MAX);
+}
+//#endregion
+//#region extensions/discord/src/monitor/threading.starter.ts
+function isDiscordForumParentType(parentType) {
+	return parentType === discord_exports.ChannelType.GuildForum || parentType === discord_exports.ChannelType.GuildMedia;
+}
+const IN_FLIGHT_DISCORD_THREAD_STARTERS = /* @__PURE__ */ new Map();
+function resolveDiscordThreadChannel(params) {
+	if (!params.isGuildMessage) return null;
+	const { message, channelInfo } = params;
+	const channel = "channel" in message ? message.channel : void 0;
+	if (channel && typeof channel === "object" && "isThread" in channel && typeof channel.isThread === "function" && channel.isThread()) return channel;
+	if (!isDiscordThreadChannelType(channelInfo?.type)) return null;
+	const messageChannelId = params.messageChannelId || resolveDiscordMessageChannelId({ message });
+	if (!messageChannelId) return null;
+	return {
+		id: messageChannelId,
+		name: channelInfo?.name ?? void 0,
+		parentId: channelInfo?.parentId ?? void 0,
+		parent: void 0,
+		ownerId: channelInfo?.ownerId ?? void 0
+	};
+}
+async function resolveDiscordThreadParentInfo(params) {
+	const { threadChannel, channelInfo, client } = params;
+	const parent = resolveDiscordChannelParentSafe(threadChannel);
+	let parentId = resolveDiscordChannelParentIdSafe(threadChannel) ?? resolveDiscordChannelIdSafe(parent) ?? channelInfo?.parentId ?? void 0;
+	if (!parentId && threadChannel.id) parentId = (await resolveDiscordChannelInfo(client, threadChannel.id))?.parentId ?? void 0;
+	if (!parentId) return {};
+	let parentName = resolveDiscordChannelNameSafe(parent);
+	const parentInfo = await resolveDiscordChannelInfo(client, parentId);
+	parentName = parentName ?? parentInfo?.name;
+	const parentType = parentInfo?.type;
+	return {
+		id: parentId,
+		name: parentName,
+		type: parentType
+	};
+}
+async function resolveDiscordThreadStarter(params) {
+	const messageChannelId = resolveDiscordThreadStarterMessageChannelId(params);
+	if (!messageChannelId) return null;
+	const cacheKey = `${params.accountId}:${params.channel.id}:${messageChannelId}`;
+	const cached = getCachedThreadStarter(cacheKey, Date.now());
+	if (cached) return cached.kind === "hit" ? cached.starter : null;
+	const inFlight = IN_FLIGHT_DISCORD_THREAD_STARTERS.get(cacheKey);
+	if (inFlight) return inFlight;
+	const pending = resolveDiscordThreadStarterUncached(params, cacheKey, messageChannelId);
+	IN_FLIGHT_DISCORD_THREAD_STARTERS.set(cacheKey, pending);
+	try {
+		return await pending;
+	} finally {
+		if (IN_FLIGHT_DISCORD_THREAD_STARTERS.get(cacheKey) === pending) IN_FLIGHT_DISCORD_THREAD_STARTERS.delete(cacheKey);
+	}
+}
+async function resolveDiscordThreadStarterUncached(params, cacheKey, messageChannelId) {
+	const cacheMiss = () => {
+		setCachedThreadStarter(cacheKey, { kind: "miss" }, Date.now());
+	};
+	try {
+		const starter = await fetchDiscordThreadStarterMessage({
+			client: params.client,
+			messageChannelId,
+			threadId: params.channel.id
+		});
+		if (!starter) {
+			cacheMiss();
+			return null;
+		}
+		const payload = buildDiscordThreadStarterPayload({
+			starter,
+			resolveTimestampMs: params.resolveTimestampMs
+		});
+		if (!payload) {
+			cacheMiss();
+			return null;
+		}
+		setCachedThreadStarter(cacheKey, {
+			kind: "hit",
+			starter: payload
+		}, Date.now());
+		return payload;
+	} catch (error) {
+		if (isDiscordThreadStarterNegativeCacheError(error)) cacheMiss();
+		return null;
+	}
+}
+function isDiscordThreadStarterNegativeCacheError(error) {
+	return error instanceof DiscordError && (error.status === 403 || error.status === 404);
+}
+function resolveDiscordThreadStarterMessageChannelId(params) {
+	return isDiscordForumParentType(params.parentType) ? params.channel.id : params.parentId;
+}
+async function fetchDiscordThreadStarterMessage(params) {
+	const starter = await getChannelMessage(params.client.rest, params.messageChannelId, params.threadId);
+	return starter ? starter : null;
+}
+function buildDiscordThreadStarterPayload(params) {
+	const text = resolveDiscordThreadStarterText(params.starter);
+	if (!text) return null;
+	return {
+		text,
+		...resolveDiscordThreadStarterIdentity(params.starter),
+		timestamp: params.resolveTimestampMs(params.starter.timestamp) ?? void 0
+	};
+}
+function resolveDiscordThreadStarterText(starter) {
+	const content = normalizeOptionalString(starter.content) ?? "";
+	const embedText = resolveDiscordEmbedText(starter.embeds);
+	const forwardedText = resolveDiscordForwardedMessagesTextFromSnapshots(starter.message_snapshots);
+	return [content || embedText || forwardedText, formatDiscordMediaText({
+		attachments: starter.attachments ?? void 0,
+		stickers: starter.sticker_items ?? void 0
+	})].filter(Boolean).join("\n");
+}
+function resolveDiscordThreadStarterIdentity(starter) {
+	return {
+		author: resolveDiscordThreadStarterAuthor(starter),
+		authorId: starter.author?.id ?? void 0,
+		authorName: starter.author?.username ?? void 0,
+		authorTag: resolveDiscordThreadStarterAuthorTag(starter.author),
+		memberRoleIds: resolveDiscordThreadStarterRoleIds(starter.member)
+	};
+}
+function resolveDiscordThreadStarterAuthor(starter) {
+	return starter.member?.nick ?? starter.member?.displayName ?? resolveDiscordThreadStarterAuthorTag(starter.author) ?? starter.author?.username ?? starter.author?.id ?? "Unknown";
+}
+function resolveDiscordThreadStarterAuthorTag(author) {
+	if (!author?.username || !author.discriminator) return;
+	if (author.discriminator !== "0") return `${author.username}#${author.discriminator}`;
+	return author.username;
+}
+function resolveDiscordThreadStarterRoleIds(member) {
+	return Array.isArray(member?.roles) ? member.roles : void 0;
+}
+function resolveDiscordReplyTarget(opts) {
+	if (opts.replyToMode === "off") return;
+	const replyToId = normalizeOptionalString(opts.replyToId);
+	if (!replyToId) return;
+	if (opts.replyToMode === "all") return replyToId;
+	return opts.hasReplied ? void 0 : replyToId;
+}
+function sanitizeDiscordThreadName(rawName, fallbackId) {
+	return truncateUtf16Safe(truncateUtf16Safe(rawName.replace(/<@!?\d+>/g, "").replace(/<@&\d+>/g, "").replace(/<#\d+>/g, "").replace(/\s+/g, " ").trim() || `Thread ${fallbackId}`, 80), 100) || `Thread ${fallbackId}`;
+}
+function resolveDiscordReplyDeliveryPlan(params) {
+	const originalReplyTarget = params.replyTarget;
+	let deliverTarget = originalReplyTarget;
+	let replyTarget = originalReplyTarget;
+	if (params.createdThreadId) {
+		deliverTarget = `channel:${params.createdThreadId}`;
+		replyTarget = deliverTarget;
+	}
+	const allowReference = deliverTarget === originalReplyTarget;
+	const replyReference = createReplyReferencePlanner({
+		replyToMode: allowReference ? params.replyToMode : "off",
+		existingId: params.threadChannel ? params.messageId : void 0,
+		startId: params.messageId,
+		allowReference
+	});
+	return {
+		deliverTarget,
+		replyTarget,
+		replyReference
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/threading.auto-thread.ts
+function resolveTrimmedDiscordMessageChannelId(params) {
+	return (params.messageChannelId || resolveDiscordMessageChannelId({ message: params.message })).trim();
+}
+function resolveDiscordAutoThreadContext(params) {
+	const createdThreadId = normalizeOptionalStringifiedId(params.createdThreadId) ?? "";
+	if (!createdThreadId) return null;
+	const parentSessionKey = normalizeOptionalString(params.parentSessionKey) ?? "";
+	if (!parentSessionKey) return null;
+	const threadSessionKey = params.groupScope === "main" ? parentSessionKey : buildAgentSessionKey({
+		agentId: params.agentId,
+		channel: params.channel,
+		peer: {
+			kind: "channel",
+			id: createdThreadId
+		}
+	});
+	const inheritsDistinctParent = threadSessionKey !== parentSessionKey;
+	return {
+		createdThreadId,
+		From: `${params.channel}:channel:${createdThreadId}`,
+		To: `channel:${createdThreadId}`,
+		OriginatingTo: `channel:${createdThreadId}`,
+		SessionKey: threadSessionKey,
+		...inheritsDistinctParent ? { ModelParentSessionKey: parentSessionKey } : {},
+		...inheritsDistinctParent && params.parentInheritanceEnabled === true ? { ParentSessionKey: parentSessionKey } : {}
+	};
+}
+async function resolveDiscordAutoThreadReplyPlan(params) {
+	const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
+	const originalReplyTarget = `channel:${params.threadChannel?.id ?? (messageChannelId || "unknown")}`;
+	const createdThreadId = await maybeCreateDiscordAutoThread({
+		client: params.client,
+		message: params.message,
+		messageChannelId: messageChannelId || void 0,
+		channel: params.channel,
+		isGuildMessage: params.isGuildMessage,
+		channelConfig: params.channelConfig,
+		threadChannel: params.threadChannel,
+		channelType: params.channelType,
+		channelName: params.channelName,
+		channelDescription: params.channelDescription,
+		baseText: params.baseText,
+		combinedBody: params.combinedBody,
+		cfg: params.cfg,
+		agentId: params.agentId
+	});
+	const deliveryPlan = resolveDiscordReplyDeliveryPlan({
+		replyTarget: originalReplyTarget,
+		replyToMode: params.replyToMode,
+		messageId: params.message.id,
+		threadChannel: params.threadChannel,
+		createdThreadId
+	});
+	const autoThreadContext = params.isGuildMessage ? resolveDiscordAutoThreadContext({
+		agentId: params.agentId,
+		channel: params.channel,
+		parentSessionKey: params.parentSessionKey,
+		createdThreadId,
+		groupScope: params.groupScope,
+		parentInheritanceEnabled: params.threadParentInheritanceEnabled
+	}) : null;
+	return {
+		...deliveryPlan,
+		createdThreadId,
+		autoThreadContext
+	};
+}
+async function maybeCreateDiscordAutoThread(params) {
+	if (!params.isGuildMessage) return;
+	if (!params.channelConfig?.autoThread) return;
+	if (params.threadChannel) return;
+	if (params.channelType === discord_exports.ChannelType.GuildForum || params.channelType === discord_exports.ChannelType.GuildMedia || params.channelType === discord_exports.ChannelType.GuildVoice || params.channelType === discord_exports.ChannelType.GuildStageVoice) return;
+	const messageChannelId = resolveTrimmedDiscordMessageChannelId(params);
+	if (!messageChannelId) return;
+	try {
+		try {
+			const existingThreadId = (await getChannelMessage(params.client.rest, messageChannelId, params.message.id))?.thread?.id;
+			if (existingThreadId) {
+				logVerbose(`discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`);
+				return existingThreadId;
+			}
+		} catch {}
+		if (params.message.author?.bot) {
+			logVerbose(`discord: autoThread skipped for bot-authored message ${messageChannelId}/${params.message.id}`);
+			return;
+		}
+		const rawThreadSource = params.baseText || params.combinedBody || "Thread";
+		const threadName = sanitizeDiscordThreadName(rawThreadSource, params.message.id);
+		const archiveDuration = params.channelConfig?.autoArchiveDuration ? Number(params.channelConfig.autoArchiveDuration) : 60;
+		const createdId = (await createThread(params.client.rest, messageChannelId, { body: {
+			name: threadName,
+			auto_archive_duration: archiveDuration
+		} }, params.message.id))?.id || "";
+		if (createdId && params.channelConfig?.autoThreadName === "generated" && params.cfg && params.agentId) {
+			const modelRef = resolveDiscordThreadTitleModelRef({
+				cfg: params.cfg,
+				channel: params.channel,
+				agentId: params.agentId,
+				threadId: createdId,
+				messageChannelId,
+				channelName: params.channelName
+			});
+			maybeRenameDiscordAutoThread({
+				client: params.client,
+				threadId: createdId,
+				currentName: threadName,
+				fallbackId: params.message.id,
+				sourceText: rawThreadSource,
+				modelRef,
+				channelName: params.channelName,
+				channelDescription: params.channelDescription,
+				cfg: params.cfg,
+				agentId: params.agentId
+			});
+		}
+		return createdId || void 0;
+	} catch (err) {
+		logVerbose(`discord: autoThread creation failed for ${messageChannelId}/${params.message.id}: ${String(err)}`);
+		try {
+			const existingThreadId = (await getChannelMessage(params.client.rest, messageChannelId, params.message.id))?.thread?.id || "";
+			if (existingThreadId) {
+				logVerbose(`discord: autoThread reusing existing thread ${existingThreadId} on ${messageChannelId}/${params.message.id}`);
+				return existingThreadId;
+			}
+		} catch {}
+		return;
+	}
+}
+function resolveDiscordThreadTitleModelRef(params) {
+	const channel = params.channel?.trim();
+	if (!channel) return;
+	const parentSessionKey = buildAgentSessionKey({
+		agentId: params.agentId,
+		channel,
+		peer: {
+			kind: "channel",
+			id: params.messageChannelId
+		}
+	});
+	const channelLabel = params.channelName?.trim();
+	const groupChannel = channelLabel ? `#${channelLabel}` : void 0;
+	return resolveChannelModelOverride({
+		cfg: params.cfg,
+		channel,
+		groupId: params.threadId,
+		groupChatType: "channel",
+		groupChannel,
+		groupSubject: groupChannel,
+		parentSessionKey
+	})?.model;
+}
+async function maybeRenameDiscordAutoThread(params) {
+	try {
+		const fallbackName = sanitizeDiscordThreadName("", params.fallbackId);
+		const generated = await generateThreadTitle({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			messageText: params.sourceText,
+			modelRef: params.modelRef,
+			channelName: params.channelName,
+			channelDescription: params.channelDescription
+		});
+		if (!generated) return;
+		const nextName = sanitizeDiscordThreadName(generated, params.fallbackId);
+		if (!nextName || nextName === params.currentName || nextName === fallbackName) return;
+		await editChannel(params.client.rest, params.threadId, { body: { name: nextName } });
+	} catch (err) {
+		logVerbose(`discord: autoThread rename failed for ${params.threadId}: ${String(err)}`);
+	}
+}
+//#endregion
+//#region extensions/discord/src/monitor/threading.ts
+var threading_exports = /* @__PURE__ */ __exportAll({
+	maybeCreateDiscordAutoThread: () => maybeCreateDiscordAutoThread,
+	resolveDiscordAutoThreadContext: () => resolveDiscordAutoThreadContext,
+	resolveDiscordAutoThreadReplyPlan: () => resolveDiscordAutoThreadReplyPlan,
+	resolveDiscordReplyDeliveryPlan: () => resolveDiscordReplyDeliveryPlan,
+	resolveDiscordReplyTarget: () => resolveDiscordReplyTarget,
+	resolveDiscordThreadChannel: () => resolveDiscordThreadChannel,
+	resolveDiscordThreadParentInfo: () => resolveDiscordThreadParentInfo,
+	resolveDiscordThreadStarter: () => resolveDiscordThreadStarter,
+	sanitizeDiscordThreadName: () => sanitizeDiscordThreadName
+});
+//#endregion
+export { resolveDiscordThreadStarter as a, resolveDiscordThreadParentInfo as i, resolveDiscordAutoThreadReplyPlan as n, sanitizeDiscordThreadName as o, resolveDiscordReplyTarget as r, threading_exports as t };