@openclaw/discord 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{thread-bindings.session-updates-Bu_CGr_O.mjs → thread-bindings.session-updates-DGSljVf6.mjs}

@@ -1,7 +1,7 @@
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+import { asOptionalObjectRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { resolveNonNegativeIntegerOption, resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
@@ -58,6 +58,12 @@ function openThreadBindingsStore() {
 		maxEntries: THREAD_BINDINGS_MAX_ENTRIES
 	});
 }
+function openThreadBindingsStoreAsync() {
+	return getDiscordRuntime().state.openKeyedStore({
+		namespace: THREAD_BINDINGS_NAMESPACE,
+		maxEntries: THREAD_BINDINGS_MAX_ENTRIES
+	});
+}
 function normalizeTargetKind(raw, targetSessionKey) {
 	if (raw === "subagent" || raw === "acp") return raw;
 	return targetSessionKey.includes(":subagent:") ? "subagent" : "acp";
@@ -69,7 +75,7 @@ function resolveBindingRecordKey(params) {
 	const threadId = normalizeOptionalStringifiedId(params.threadId);
 	if (!threadId) return;
 	return toBindingRecordKey({
-		accountId: normalizeAccountId(params.accountId),
+		accountId: params.accountId,
 		threadId
 	});
 }
@@ -92,7 +98,7 @@ function normalizePersistedBinding(threadIdKey, raw) {
 	const idleTimeoutMs = resolveOptionalIntegerOption(value.idleTimeoutMs, { min: 0 });
 	const maxAgeMs = resolveOptionalIntegerOption(value.maxAgeMs, { min: 0 });
 	const metadata = value.metadata && typeof value.metadata === "object" ? { ...value.metadata } : void 0;
-	const record = {
+	return {
 		accountId,
 		channelId,
 		threadId,
@@ -101,15 +107,14 @@ function normalizePersistedBinding(threadIdKey, raw) {
 		agentId,
 		boundBy,
 		boundAt,
-		lastActivityAt
+		lastActivityAt,
+		...label !== void 0 ? { label } : {},
+		...webhookId !== void 0 ? { webhookId } : {},
+		...webhookToken !== void 0 ? { webhookToken } : {},
+		...idleTimeoutMs !== void 0 ? { idleTimeoutMs } : {},
+		...maxAgeMs !== void 0 ? { maxAgeMs } : {},
+		...metadata !== void 0 ? { metadata } : {}
 	};
-	if (label !== void 0) record.label = label;
-	if (webhookId !== void 0) record.webhookId = webhookId;
-	if (webhookToken !== void 0) record.webhookToken = webhookToken;
-	if (idleTimeoutMs !== void 0) record.idleTimeoutMs = idleTimeoutMs;
-	if (maxAgeMs !== void 0) record.maxAgeMs = maxAgeMs;
-	if (metadata !== void 0) record.metadata = metadata;
-	return record;
 }
 function normalizeThreadBindingDurationMs(raw, defaultsTo) {
 	const durationMs = resolveOptionalIntegerOption(raw);
@@ -145,17 +150,11 @@ function resolvePreparedThreadBindingLifecycle(params) {
 	};
 }
 function resolveThreadBindingInactivityExpiresAt(params) {
-	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMs({
-		record: params.record,
-		defaultIdleTimeoutMs: params.defaultIdleTimeoutMs
-	});
+	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMs(params);
 	return resolveTimestampExpiry(params.record.lastActivityAt, idleTimeoutMs);
 }
 function resolveThreadBindingMaxAgeExpiresAt(params) {
-	const maxAgeMs = resolveThreadBindingMaxAgeMs({
-		record: params.record,
-		defaultMaxAgeMs: params.defaultMaxAgeMs
-	});
+	const maxAgeMs = resolveThreadBindingMaxAgeMs(params);
 	return resolveTimestampExpiry(params.record.boundAt, maxAgeMs);
 }
 function linkSessionBinding(targetSessionKey, bindingKey) {
@@ -180,10 +179,7 @@ function rememberReusableWebhook(record) {
 	const webhookId = record.webhookId?.trim();
 	const webhookToken = record.webhookToken?.trim();
 	if (!webhookId || !webhookToken) return;
-	const key = toReusableWebhookKey({
-		accountId: record.accountId,
-		channelId: record.channelId
-	});
+	const key = toReusableWebhookKey(record);
 	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.set(key, {
 		webhookId,
 		webhookToken
@@ -200,10 +196,7 @@ function refreshUnboundThreadWebhookIdentity(record) {
 	});
 }
 function setBindingRecord(record) {
-	const bindingKey = toBindingRecordKey({
-		accountId: record.accountId,
-		threadId: record.threadId
-	});
+	const bindingKey = toBindingRecordKey(record);
 	const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
 	if (existing) unlinkSessionBinding(existing.targetSessionKey, bindingKey);
 	BINDINGS_BY_THREAD_ID.set(bindingKey, record);
@@ -234,8 +227,7 @@ function restoreBindings(entries) {
 	THREAD_BINDINGS_STATE.loadedPersistentBindings = entries.length > 0;
 	for (const entry of entries) {
 		const normalized = normalizePersistedBinding(entry.key, entry.value);
-		if (!normalized) continue;
-		setBindingRecord(normalized);
+		if (normalized) setBindingRecord(normalized);
 	}
 }
 function ensureBindingsLoaded() {
@@ -253,10 +245,7 @@ function ensureBindingsLoaded() {
 async function loadBindingsAsync() {
 	let entries;
 	try {
-		entries = await getDiscordRuntime().state.openKeyedStore({
-			namespace: THREAD_BINDINGS_NAMESPACE,
-			maxEntries: THREAD_BINDINGS_MAX_ENTRIES
-		}).entries();
+		entries = await openThreadBindingsStoreAsync().entries();
 	} catch {
 		if (!THREAD_BINDINGS_STATE.loadedBindings) {
 			beginBindingsLoad();
@@ -279,34 +268,28 @@ async function ensureBindingsLoadedAsync() {
 	}
 }
 function resolveBindingIdsForSession(params) {
-	const key = params.targetSessionKey.trim();
-	if (!key) return [];
-	const ids = BINDINGS_BY_SESSION_KEY.get(key);
-	if (!ids) return [];
 	const out = [];
-	for (const bindingKey of ids.values()) {
+	for (const bindingKey of BINDINGS_BY_SESSION_KEY.get(params.targetSessionKey.trim()) ?? []) {
 		const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
-		if (!record) continue;
-		if (params.accountId && record.accountId !== params.accountId) continue;
-		if (params.targetKind && record.targetKind !== params.targetKind) continue;
-		out.push(bindingKey);
+		if (record && (!params.accountId || record.accountId === params.accountId) && (!params.targetKind || record.targetKind === params.targetKind)) out.push(bindingKey);
 	}
 	return out;
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.persistence.ts
 function shouldPersistAnyBindingState() {
-	for (const value of PERSIST_BY_ACCOUNT_ID.values()) if (value) return true;
-	return false;
+	return [...PERSIST_BY_ACCOUNT_ID.values()].some(Boolean);
 }
 function shouldPersistBindingMutations() {
-	if (shouldPersistAnyBindingState()) return true;
-	return THREAD_BINDINGS_STATE.loadedPersistentBindings;
+	return shouldPersistAnyBindingState() || THREAD_BINDINGS_STATE.loadedPersistentBindings;
 }
 function snapshotThreadBindingJson(value) {
 	const serialized = JSON.stringify(value);
 	return serialized ? JSON.parse(serialized) : void 0;
 }
+function snapshotThreadBindingMetadata(input) {
+	return asOptionalObjectRecord(snapshotThreadBindingJson(input.metadata ? { ...input.metadata } : void 0));
+}
 function toPersistedBindingRecord(record) {
 	return normalizePersistedBinding(record.threadId, snapshotThreadBindingJson(record)) ?? { ...record };
 }
@@ -337,7 +320,6 @@ async function commitBindingRecord(params) {
 	const revision = THREAD_BINDINGS_STATE.revision;
 	let authorityRefused = false;
 	let targetCommitted = false;
-	let committedWrites = 0;
 	const assertCurrent = () => {
 		try {
 			params.assertCurrent?.();
@@ -362,10 +344,7 @@ async function commitBindingRecord(params) {
 		};
 		THREAD_BINDINGS_STATE.activePersistence = active;
 		try {
-			const store = getDiscordRuntime().state.openKeyedStore({
-				namespace: THREAD_BINDINGS_NAMESPACE,
-				maxEntries: THREAD_BINDINGS_MAX_ENTRIES
-			});
+			const store = openThreadBindingsStoreAsync();
 			for (const [key, record] of records) {
 				assertCurrent();
 				const persisted = toPersistedBindingRecord(record);
@@ -374,7 +353,6 @@ async function commitBindingRecord(params) {
 				await store.register(key, persisted, { assertCurrent });
 				active.writingKey = void 0;
 				active.committedKeys.add(key);
-				committedWrites += 1;
 				targetCommitted ||= key === params.bindingKey;
 			}
 			assertCurrent();
@@ -385,7 +363,6 @@ async function commitBindingRecord(params) {
 				await store.delete(entry.key, { assertCurrent });
 				active.writingKey = void 0;
 				active.committedKeys.add(entry.key);
-				committedWrites += 1;
 				targetCommitted ||= entry.key === params.bindingKey;
 			}
 			if (!params.next) targetCommitted = true;
@@ -393,6 +370,7 @@ async function commitBindingRecord(params) {
 			THREAD_BINDINGS_STATE.loadedPersistentBindings = records.size > 0;
 			THREAD_BINDINGS_STATE.lastPersistedAtMs = now;
 		} catch (error) {
+			const committedWrites = active.committedKeys.size;
 			let failure = error;
 			if (!authorityRefused) try {
 				assertCurrent();
@@ -530,26 +508,21 @@ function removeBindingRecordSync(bindingKey) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
-function normalizeNonNegativeMs(raw) {
-	if (!Number.isFinite(raw)) return 0;
-	return Math.max(0, Math.floor(raw));
-}
 function resolveBindingIdsForTargetSession(params) {
 	ensureBindingsLoaded();
-	const targetSessionKey = params.targetSessionKey.trim();
-	if (!targetSessionKey) return [];
 	return resolveBindingIdsForSession({
-		targetSessionKey,
-		accountId: params.accountId ? normalizeAccountId(params.accountId) : void 0,
-		targetKind: params.targetKind
+		...params,
+		accountId: params.accountId ? normalizeAccountId(params.accountId) : void 0
 	});
 }
 function mutateBindingsForTargetSession(params, update, onRemoved) {
 	const accountId = params.accountId ? normalizeAccountId(params.accountId) : void 0;
-	const admittedOwners = new Map([...MANAGERS_BY_ACCOUNT_ID].filter(([ownerAccountId]) => accountId === void 0 || ownerAccountId === accountId).map(([ownerAccountId, manager]) => [ownerAccountId, {
+	const admittedOwners = /* @__PURE__ */ new Map();
+	const ownerSnapshot = [...MANAGERS_BY_ACCOUNT_ID];
+	for (const [ownerAccountId, manager] of ownerSnapshot) if (accountId === void 0 || ownerAccountId === accountId) admittedOwners.set(ownerAccountId, {
 		manager,
 		stopping: manager.isStopping()
-	}]));
+	});
 	return runThreadBindingAccountOperation([...admittedOwners.values()].map(({ manager }) => manager), () => runThreadBindingMutation(async () => {
 		await ensureBindingsLoadedAsync();
 		const ids = resolveBindingIdsForTargetSession(params);
@@ -605,45 +578,33 @@ function updateBindingsForTargetSessionSync(ids, update) {
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-updates.ts
-async function setThreadBindingIdleTimeoutBySessionKeyAsync(input) {
-	const params = { ...input };
-	const idleTimeoutMs = normalizeNonNegativeMs(params.idleTimeoutMs);
-	return mutateBindingsForTargetSession(params, (existing, now) => ({
+function createDurationUpdate(field, raw) {
+	const duration = resolveNonNegativeIntegerOption(raw, 0);
+	return (existing, now) => ({
 		...existing,
-		idleTimeoutMs,
+		[field]: duration,
+		...field === "maxAgeMs" ? { boundAt: now } : {},
 		lastActivityAt: now
-	}));
+	});
 }
-async function setThreadBindingMaxAgeBySessionKeyAsync(input) {
-	const params = { ...input };
-	const maxAgeMs = normalizeNonNegativeMs(params.maxAgeMs);
-	return mutateBindingsForTargetSession(params, (existing, now) => ({
-		...existing,
-		maxAgeMs,
-		boundAt: now,
-		lastActivityAt: now
-	}));
+function createDurationSetters(field) {
+	return {
+		setAsync: async (input) => {
+			const params = { ...input };
+			return mutateBindingsForTargetSession(params, createDurationUpdate(field, params[field]));
+		},
+		set: (params) => {
+			return updateBindingsForTargetSessionSync(resolveBindingIdsForTargetSession(params), createDurationUpdate(field, params[field]));
+		}
+	};
 }
+const idleSetters = createDurationSetters("idleTimeoutMs");
+const maxAgeSetters = createDurationSetters("maxAgeMs");
+const setThreadBindingIdleTimeoutBySessionKeyAsync = idleSetters.setAsync;
+const setThreadBindingMaxAgeBySessionKeyAsync = maxAgeSetters.setAsync;
 /** @deprecated Use the awaited lifecycle setter; retained for the generic SDK contract. */
-function setThreadBindingIdleTimeoutBySessionKey(params) {
-	const ids = resolveBindingIdsForTargetSession(params);
-	const idleTimeoutMs = normalizeNonNegativeMs(params.idleTimeoutMs);
-	return updateBindingsForTargetSessionSync(ids, (existing, now) => ({
-		...existing,
-		idleTimeoutMs,
-		lastActivityAt: now
-	}));
-}
+const setThreadBindingIdleTimeoutBySessionKey = idleSetters.set;
 /** @deprecated Use the awaited lifecycle setter; retained for the generic SDK contract. */
-function setThreadBindingMaxAgeBySessionKey(params) {
-	const ids = resolveBindingIdsForTargetSession(params);
-	const maxAgeMs = normalizeNonNegativeMs(params.maxAgeMs);
-	return updateBindingsForTargetSessionSync(ids, (existing, now) => ({
-		...existing,
-		maxAgeMs,
-		boundAt: now,
-		lastActivityAt: now
-	}));
-}
+const setThreadBindingMaxAgeBySessionKey = maxAgeSetters.set;
 //#endregion
-export { resolveBindingRecordKey as A, getThreadBindingToken as C, rememberReusableWebhook as D, refreshUnboundThreadWebhookIdentity as E, resolveThreadBindingMaxAgeMs as F, shouldDefaultPersist as I, toBindingRecordKey as L, resolveThreadBindingIdleTimeoutMs as M, resolveThreadBindingInactivityExpiresAt as N, rememberThreadBindingToken as O, resolveThreadBindingMaxAgeExpiresAt as P, toReusableWebhookKey as R, forgetThreadBindingToken as S, normalizeThreadBindingDurationMs as T, MANAGERS_BY_ACCOUNT_ID as _, mutateBindingsForTargetSession as a, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as b, drainThreadBindingAccountOperations as c, runThreadBindingAccountOperation as d, runThreadBindingMutation as f, BINDINGS_BY_THREAD_ID as g, updateBindingRecordSync as h, setThreadBindingMaxAgeBySessionKeyAsync as i, resolvePreparedThreadBindingLifecycle as j, resolveBindingIdsForSession as k, drainThreadBindingMutations as l, snapshotThreadBindingJson as m, setThreadBindingIdleTimeoutBySessionKeyAsync as n, resolveBindingIdsForTargetSession as o, shouldPersistAnyBindingState as p, setThreadBindingMaxAgeBySessionKey as r, commitBindingRecord as s, setThreadBindingIdleTimeoutBySessionKey as t, removeBindingRecordSync as u, PERSIST_BY_ACCOUNT_ID as v, normalizeTargetKind as w, ensureBindingsLoadedAsync as x, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as y };
+export { resolveBindingRecordKey as A, getThreadBindingToken as C, rememberReusableWebhook as D, refreshUnboundThreadWebhookIdentity as E, resolveThreadBindingMaxAgeMs as F, shouldDefaultPersist as I, toBindingRecordKey as L, resolveThreadBindingIdleTimeoutMs as M, resolveThreadBindingInactivityExpiresAt as N, rememberThreadBindingToken as O, resolveThreadBindingMaxAgeExpiresAt as P, toReusableWebhookKey as R, forgetThreadBindingToken as S, normalizeThreadBindingDurationMs as T, MANAGERS_BY_ACCOUNT_ID as _, mutateBindingsForTargetSession as a, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as b, drainThreadBindingAccountOperations as c, runThreadBindingAccountOperation as d, runThreadBindingMutation as f, BINDINGS_BY_THREAD_ID as g, updateBindingRecordSync as h, setThreadBindingMaxAgeBySessionKeyAsync as i, resolvePreparedThreadBindingLifecycle as j, resolveBindingIdsForSession as k, drainThreadBindingMutations as l, snapshotThreadBindingMetadata as m, setThreadBindingIdleTimeoutBySessionKeyAsync as n, resolveBindingIdsForTargetSession as o, shouldPersistAnyBindingState as p, setThreadBindingMaxAgeBySessionKey as r, commitBindingRecord as s, setThreadBindingIdleTimeoutBySessionKey as t, removeBindingRecordSync as u, PERSIST_BY_ACCOUNT_ID as v, normalizeTargetKind as w, ensureBindingsLoadedAsync as x, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as y };

package/dist/.setup/threading-BKe3E3tp.mjs

@@ -0,0 +1,246 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { ct as createThread, ft as getChannelMessage, t as discord_exports } from "./discord-BGqgx-yd.mjs";
+import { d as resolveDiscordReplyDeliveryPlan, f as resolveDiscordReplyTarget, g as sanitizeDiscordThreadName, h as resolveDiscordThreadStarter, j as resolveDiscordMessageChannelId, m as resolveDiscordThreadParentInfo, p as resolveDiscordThreadChannel } from "./transcripts-source-0qQYVu2H.mjs";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { buildAgentSessionKey } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { Routes } from "discord-api-types/v10";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-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 generated = await generateConversationLabel({
+			cfg: params.cfg,
+			agentId: params.agentId,
+			userMessage,
+			prompt: DISCORD_THREAD_TITLE_SYSTEM_PROMPT,
+			...params.modelRef ? { modelRef: params.modelRef } : {},
+			timeoutMs: Math.max(100, Math.floor(params.timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS)),
+			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 = truncateThreadTitleText(params.sourceText, MAX_THREAD_TITLE_SOURCE_CHARS);
+	const channelName = normalizeTitleContextField(params.channelName, MAX_THREAD_TITLE_CHANNEL_NAME_CHARS);
+	const channelDescription = normalizeTitleContextField(params.channelDescription, MAX_THREAD_TITLE_CHANNEL_DESCRIPTION_CHARS);
+	return [
+		channelName ? `Channel: ${channelName}` : void 0,
+		channelDescription ? `Channel description: ${channelDescription}` : void 0,
+		`Message:\n${sourceText}`
+	].filter(Boolean).join("\n\n");
+}
+function truncateThreadTitleText(text, maxChars) {
+	if (text.length <= maxChars) return text;
+	return `${truncateUtf16Safe(text, maxChars)}...`;
+}
+function normalizeGeneratedThreadTitle(raw) {
+	return stripThreadTitleWrappers(raw.replace(/\r/g, "").split("\n").find((line) => line.trim() && !line.trim().startsWith("```")) ?? "");
+}
+function stripThreadTitleWrappers(raw) {
+	let current = raw.trim();
+	let previous = "";
+	while (current && current !== previous) {
+		previous = current;
+		current = current.replace(/^["'`]+|["'`]+$/g, "").trim();
+		for (const marker of [
+			"**",
+			"__",
+			"*",
+			"_",
+			"~~"
+		]) current = stripBalancedWrapper(current, marker);
+	}
+	return current;
+}
+function stripBalancedWrapper(text, marker) {
+	if (text.length < marker.length * 2 + 1 || !text.startsWith(marker) || !text.endsWith(marker)) return text;
+	const inner = text.slice(marker.length, text.length - marker.length);
+	return inner.includes(marker) ? text : inner;
+}
+function normalizeTitleContextField(raw, maxChars) {
+	const value = raw?.trim();
+	if (!value) return;
+	return truncateThreadTitleText(value.replace(/\s+/g, " "), maxChars);
+}
+//#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({
+		...params,
+		messageChannelId: messageChannelId || void 0
+	});
+	const deliveryPlan = resolveDiscordReplyDeliveryPlan({
+		replyTarget: originalReplyTarget,
+		replyToMode: params.replyToMode,
+		messageId: params.message.id,
+		threadChannel: params.threadChannel,
+		createdThreadId
+	});
+	const autoThreadContext = params.isGuildMessage ? resolveDiscordAutoThreadContext({
+		...params,
+		createdThreadId,
+		parentInheritanceEnabled: params.threadParentInheritanceEnabled
+	}) : null;
+	return {
+		...deliveryPlan,
+		createdThreadId,
+		autoThreadContext
+	};
+}
+async function maybeCreateDiscordAutoThread(params) {
+	if (!params.isGuildMessage || !params.channelConfig?.autoThread || 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;
+	const findExistingThread = async () => {
+		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 {}
+	};
+	try {
+		const existingThreadId = await findExistingThread();
+		if (existingThreadId) return existingThreadId;
+		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)}`);
+		return findExistingThread();
+	}
+}
+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({
+			...params,
+			messageText: params.sourceText
+		});
+		if (!generated) return;
+		const nextName = sanitizeDiscordThreadName(generated, params.fallbackId);
+		if (!nextName || nextName === params.currentName || nextName === fallbackName) return;
+		await params.client.rest.patch(Routes.channel(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 { resolveDiscordAutoThreadReplyPlan as n, threading_exports as t };

package/dist/.setup/{timeouts-pun7VJ02.mjs → timeouts-CuNARfyw.mjs}

@@ -1,4 +1,5 @@
 import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
 //#region extensions/discord/src/monitor/timeouts.ts
 const DISCORD_DEFAULT_LISTENER_TIMEOUT_MS = 12e4;
 const DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS = 18e5;
@@ -27,7 +28,6 @@ async function runDiscordTaskWithTimeout(params) {
 	const abortSignals = [...params.abortSignals ?? [], timeoutAbortController?.signal].filter((signal) => Boolean(signal));
 	const mergedAbortSignal = abortSignals.length > 1 ? AbortSignal.any(abortSignals) : abortSignals[0];
 	let timedOut = false;
-	let timeoutHandle = null;
 	const runPromise = params.run(mergedAbortSignal).catch((error) => {
 		if (!timedOut) throw error;
 		if (timeoutAbortController?.signal.aborted && isAbortError(error)) {
@@ -36,25 +36,17 @@ async function runDiscordTaskWithTimeout(params) {
 		}
 		params.onErrorAfterTimeout?.(error);
 	});
-	try {
-		if (!timeoutMs) {
-			await runPromise;
-			return false;
-		}
-		const timeoutPromise = new Promise((resolve) => {
-			timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
-			timeoutHandle.unref?.();
-		});
-		if (await Promise.race([runPromise.then(() => "completed"), timeoutPromise]) === "timeout") {
-			timedOut = true;
-			timeoutAbortController?.abort();
-			await params.onTimeout(timeoutMs);
-			return true;
-		}
+	if (!timeoutMs) {
+		await runPromise;
 		return false;
-	} finally {
-		if (timeoutHandle) clearTimeout(timeoutHandle);
 	}
+	if (await raceWithTimeout(runPromise.then(() => "completed"), timeoutMs, () => "timeout", { ref: false }) === "timeout") {
+		timedOut = true;
+		timeoutAbortController?.abort();
+		await params.onTimeout(timeoutMs);
+		return true;
+	}
+	return false;
 }
 async function withAbortTimeout(params) {
 	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);