@openclaw/discord 2026.9.8 → 2026.10.1-beta.2

package/dist/.setup/{thread-bindings.session-updates-CshfKghV.mjs → thread-bindings.session-updates-C9aKtVs6.mjs}

@@ -1,8 +1,299 @@
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
-import { O as setBindingRecord, a as THREAD_BINDINGS_MAX_ENTRIES, b as removeBindingRecord, g as openThreadBindingsStore, l as ensureBindingsLoaded, n as MANAGERS_BY_ACCOUNT_ID, o as THREAD_BINDINGS_NAMESPACE, p as normalizePersistedBinding, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDINGS_STATE, t as BINDINGS_BY_THREAD_ID, u as ensureBindingsLoadedAsync, x as resolveBindingIdsForSession } from "./thread-bindings.state-g6v9zAym.mjs";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { 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 { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
 import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/outbound-echo-runtime";
+import { resolveThreadBindingExpiry } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.state.ts
+const THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.discordThreadBindingsState");
+function createThreadBindingsGlobalState() {
+	return {
+		managersByAccountId: /* @__PURE__ */ new Map(),
+		bindingsByThreadId: /* @__PURE__ */ new Map(),
+		bindingsBySessionKey: /* @__PURE__ */ new Map(),
+		tokensByAccountId: /* @__PURE__ */ new Map(),
+		reusableWebhooksByAccountChannel: /* @__PURE__ */ new Map(),
+		persistByAccountId: /* @__PURE__ */ new Map(),
+		loadedBindings: false,
+		loadedPersistentBindings: false,
+		persistenceAvailable: true,
+		lastPersistedAtMs: 0,
+		revision: 0,
+		mutationTail: Promise.resolve(),
+		accountOperationTails: /* @__PURE__ */ new WeakMap()
+	};
+}
+const THREAD_BINDINGS_STATE = resolveGlobalSingleton(THREAD_BINDINGS_STATE_KEY, createThreadBindingsGlobalState);
+THREAD_BINDINGS_STATE.accountOperationTails ??= /* @__PURE__ */ new WeakMap();
+const MANAGERS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.managersByAccountId;
+const BINDINGS_BY_THREAD_ID = THREAD_BINDINGS_STATE.bindingsByThreadId;
+const BINDINGS_BY_SESSION_KEY = THREAD_BINDINGS_STATE.bindingsBySessionKey;
+const TOKENS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.tokensByAccountId;
+const REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL = THREAD_BINDINGS_STATE.reusableWebhooksByAccountChannel;
+const PERSIST_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.persistByAccountId;
+const THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS = 15e3;
+const THREAD_BINDINGS_NAMESPACE = "thread-bindings";
+const THREAD_BINDINGS_MAX_ENTRIES = 1e4;
+function rememberThreadBindingToken(params) {
+	const normalizedAccountId = normalizeAccountId(params.accountId);
+	const token = params.token?.trim();
+	if (!token) return;
+	TOKENS_BY_ACCOUNT_ID.set(normalizedAccountId, token);
+}
+function forgetThreadBindingToken(accountId) {
+	TOKENS_BY_ACCOUNT_ID.delete(normalizeAccountId(accountId));
+}
+function getThreadBindingToken(accountId) {
+	return TOKENS_BY_ACCOUNT_ID.get(normalizeAccountId(accountId));
+}
+function shouldDefaultPersist() {
+	return !(process.env.VITEST || false);
+}
+function openThreadBindingsStore() {
+	return getDiscordRuntime().state.openSyncKeyedStore({
+		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";
+}
+function toBindingRecordKey(params) {
+	return `${normalizeAccountId(params.accountId)}:${params.threadId.trim()}`;
+}
+function resolveBindingRecordKey(params) {
+	const threadId = normalizeOptionalStringifiedId(params.threadId);
+	if (!threadId) return;
+	return toBindingRecordKey({
+		accountId: normalizeAccountId(params.accountId),
+		threadId
+	});
+}
+function normalizePersistedBinding(threadIdKey, raw) {
+	if (!raw || typeof raw !== "object") return null;
+	const value = raw;
+	const threadId = normalizeOptionalStringifiedId(value.threadId ?? threadIdKey);
+	const channelId = normalizeOptionalString(value.channelId) ?? "";
+	const targetSessionKey = normalizeOptionalString(value.targetSessionKey) ?? "";
+	if (!threadId || !channelId || !targetSessionKey) return null;
+	const accountId = normalizeAccountId(value.accountId);
+	const targetKind = normalizeTargetKind(value.targetKind, targetSessionKey);
+	const agentId = (normalizeOptionalString(value.agentId) ?? "") || resolveAgentIdFromSessionKey(targetSessionKey);
+	const label = normalizeOptionalString(value.label);
+	const webhookId = normalizeOptionalString(value.webhookId);
+	const webhookToken = normalizeOptionalString(value.webhookToken);
+	const boundBy = normalizeOptionalString(value.boundBy) ?? "system";
+	const boundAt = resolveOptionalIntegerOption(value.boundAt) ?? Date.now();
+	const lastActivityAt = resolveOptionalIntegerOption(value.lastActivityAt, { min: 0 }) ?? boundAt;
+	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 = {
+		accountId,
+		channelId,
+		threadId,
+		targetKind,
+		targetSessionKey,
+		agentId,
+		boundBy,
+		boundAt,
+		lastActivityAt
+	};
+	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);
+	return durationMs !== void 0 && durationMs >= 0 ? durationMs : defaultsTo;
+}
+function resolveThreadBindingIdleTimeoutMs(params) {
+	return resolveNonNegativeIntegerOption(params.record.idleTimeoutMs, params.defaultIdleTimeoutMs);
+}
+function resolveThreadBindingMaxAgeMs(params) {
+	return resolveNonNegativeIntegerOption(params.record.maxAgeMs, params.defaultMaxAgeMs);
+}
+function resolveTimestampExpiry(timestamp, durationMs) {
+	if (durationMs <= 0) return;
+	const at = Math.floor(timestamp);
+	return Number.isFinite(at) && at > 0 ? at + durationMs : void 0;
+}
+function resolvePreparedThreadBindingLifecycle(params) {
+	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMs({
+		record: params.record,
+		defaultIdleTimeoutMs: params.idleTimeoutMs
+	});
+	const maxAgeMs = resolveThreadBindingMaxAgeMs({
+		record: params.record,
+		defaultMaxAgeMs: params.maxAgeMs
+	});
+	return {
+		idleTimeoutMs,
+		maxAgeMs,
+		...resolveThreadBindingExpiry({
+			inactivityExpiresAt: resolveTimestampExpiry(params.record.lastActivityAt, idleTimeoutMs),
+			maxAgeExpiresAt: resolveTimestampExpiry(params.record.boundAt, maxAgeMs)
+		})
+	};
+}
+function resolveThreadBindingInactivityExpiresAt(params) {
+	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMs({
+		record: params.record,
+		defaultIdleTimeoutMs: params.defaultIdleTimeoutMs
+	});
+	return resolveTimestampExpiry(params.record.lastActivityAt, idleTimeoutMs);
+}
+function resolveThreadBindingMaxAgeExpiresAt(params) {
+	const maxAgeMs = resolveThreadBindingMaxAgeMs({
+		record: params.record,
+		defaultMaxAgeMs: params.defaultMaxAgeMs
+	});
+	return resolveTimestampExpiry(params.record.boundAt, maxAgeMs);
+}
+function linkSessionBinding(targetSessionKey, bindingKey) {
+	const key = targetSessionKey.trim();
+	if (!key) return;
+	const threads = BINDINGS_BY_SESSION_KEY.get(key) ?? /* @__PURE__ */ new Set();
+	threads.add(bindingKey);
+	BINDINGS_BY_SESSION_KEY.set(key, threads);
+}
+function unlinkSessionBinding(targetSessionKey, bindingKey) {
+	const key = targetSessionKey.trim();
+	if (!key) return;
+	const threads = BINDINGS_BY_SESSION_KEY.get(key);
+	if (!threads) return;
+	threads.delete(bindingKey);
+	if (threads.size === 0) BINDINGS_BY_SESSION_KEY.delete(key);
+}
+function toReusableWebhookKey(params) {
+	return `${normalizeLowercaseStringOrEmpty(params.accountId)}:${params.channelId.trim()}`;
+}
+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
+	});
+	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.set(key, {
+		webhookId,
+		webhookToken
+	});
+}
+function refreshUnboundThreadWebhookIdentity(record) {
+	const sourceId = record.webhookId?.trim();
+	if (!sourceId) return;
+	recordOutboundMessageIdentity({
+		channel: "discord",
+		accountId: record.accountId,
+		conversationId: record.threadId,
+		sourceId
+	});
+}
+function setBindingRecord(record) {
+	const bindingKey = toBindingRecordKey({
+		accountId: record.accountId,
+		threadId: record.threadId
+	});
+	const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+	if (existing) unlinkSessionBinding(existing.targetSessionKey, bindingKey);
+	BINDINGS_BY_THREAD_ID.set(bindingKey, record);
+	THREAD_BINDINGS_STATE.revision += 1;
+	linkSessionBinding(record.targetSessionKey, bindingKey);
+	rememberReusableWebhook(record);
+}
+function removeBindingRecord(bindingKeyRaw) {
+	const key = bindingKeyRaw.trim();
+	if (!key) return null;
+	const existing = BINDINGS_BY_THREAD_ID.get(key);
+	if (!existing) return null;
+	BINDINGS_BY_THREAD_ID.delete(key);
+	THREAD_BINDINGS_STATE.revision += 1;
+	unlinkSessionBinding(existing.targetSessionKey, key);
+	return existing;
+}
+function beginBindingsLoad() {
+	THREAD_BINDINGS_STATE.loadedBindings = true;
+	BINDINGS_BY_THREAD_ID.clear();
+	THREAD_BINDINGS_STATE.revision += 1;
+	BINDINGS_BY_SESSION_KEY.clear();
+	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
+	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
+}
+function restoreBindings(entries) {
+	THREAD_BINDINGS_STATE.persistenceAvailable = true;
+	THREAD_BINDINGS_STATE.loadedPersistentBindings = entries.length > 0;
+	for (const entry of entries) {
+		const normalized = normalizePersistedBinding(entry.key, entry.value);
+		if (!normalized) continue;
+		setBindingRecord(normalized);
+	}
+}
+function ensureBindingsLoaded() {
+	if (THREAD_BINDINGS_STATE.loadedBindings) return;
+	beginBindingsLoad();
+	let entries;
+	try {
+		entries = openThreadBindingsStore().entries();
+	} catch {
+		THREAD_BINDINGS_STATE.persistenceAvailable = false;
+		return;
+	}
+	restoreBindings(entries);
+}
+async function loadBindingsAsync() {
+	let entries;
+	try {
+		entries = await getDiscordRuntime().state.openKeyedStore({
+			namespace: THREAD_BINDINGS_NAMESPACE,
+			maxEntries: THREAD_BINDINGS_MAX_ENTRIES
+		}).entries();
+	} catch {
+		if (!THREAD_BINDINGS_STATE.loadedBindings) {
+			beginBindingsLoad();
+			THREAD_BINDINGS_STATE.persistenceAvailable = false;
+			logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
+		}
+		return;
+	}
+	if (THREAD_BINDINGS_STATE.loadedBindings) return;
+	beginBindingsLoad();
+	restoreBindings(entries);
+}
+async function ensureBindingsLoadedAsync() {
+	if (THREAD_BINDINGS_STATE.loadedBindings) return;
+	const loading = THREAD_BINDINGS_STATE.loadingBindings ??= loadBindingsAsync();
+	try {
+		await loading;
+	} finally {
+		if (THREAD_BINDINGS_STATE.loadingBindings === loading) delete THREAD_BINDINGS_STATE.loadingBindings;
+	}
+}
+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()) {
+		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);
+	}
+	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;
@@ -247,10 +538,9 @@ function resolveBindingIdsForTargetSession(params) {
 	ensureBindingsLoaded();
 	const targetSessionKey = params.targetSessionKey.trim();
 	if (!targetSessionKey) return [];
-	const accountId = params.accountId ? normalizeAccountId(params.accountId) : void 0;
 	return resolveBindingIdsForSession({
 		targetSessionKey,
-		accountId,
+		accountId: params.accountId ? normalizeAccountId(params.accountId) : void 0,
 		targetKind: params.targetKind
 	});
 }
@@ -356,4 +646,4 @@ function setThreadBindingMaxAgeBySessionKey(params) {
 	}));
 }
 //#endregion
-export { mutateBindingsForTargetSession as a, drainThreadBindingAccountOperations as c, runThreadBindingAccountOperation as d, runThreadBindingMutation as f, updateBindingRecordSync as h, setThreadBindingMaxAgeBySessionKeyAsync as i, 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 };
+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 };

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

@@ -56,27 +56,14 @@ async function runDiscordTaskWithTimeout(params) {
 		if (timeoutHandle) clearTimeout(timeoutHandle);
 	}
 }
-async function raceWithTimeout(params) {
-	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);
-	let timeoutTimer;
-	const timeoutPromise = new Promise((resolve) => {
-		timeoutTimer = setTimeout(() => resolve(params.onTimeout()), timeoutMs);
-		timeoutTimer.unref?.();
-	});
-	try {
-		return await Promise.race([params.promise, timeoutPromise]);
-	} finally {
-		if (timeoutTimer) clearTimeout(timeoutTimer);
-	}
-}
 async function withAbortTimeout(params) {
 	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);
 	const controller = new AbortController();
 	let timeoutTimer;
 	const timeoutPromise = new Promise((_, reject) => {
 		timeoutTimer = setTimeout(() => {
-			controller.abort();
 			reject(params.createTimeoutError());
+			controller.abort();
 		}, timeoutMs);
 		timeoutTimer.unref?.();
 	});
@@ -87,4 +74,4 @@ async function withAbortTimeout(params) {
 	}
 }
 //#endregion
-export { isAbortError as a, raceWithTimeout as c, DISCORD_DEFAULT_LISTENER_TIMEOUT_MS as i, runDiscordTaskWithTimeout as l, DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS as n, normalizeDiscordInboundWorkerTimeoutMs as o, DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS as r, normalizeDiscordListenerTimeoutMs as s, DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS as t, withAbortTimeout as u };
+export { isAbortError as a, runDiscordTaskWithTimeout as c, DISCORD_DEFAULT_LISTENER_TIMEOUT_MS as i, withAbortTimeout as l, DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS as n, normalizeDiscordInboundWorkerTimeoutMs as o, DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS as r, normalizeDiscordListenerTimeoutMs as s, DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS as t };

package/dist/.setup/{transcripts-source-p8EV179h.mjs → transcripts-source-CNWswry-.mjs}

@@ -1,16 +1,17 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { _ as DiscordError, ft as editChannel, ht as getChannelMessage, lt as createThread, t as discord_exports } from "./discord-0xJYfdDD.mjs";
-import { D as getDiscordEndpointRuntime, f as resolveDiscordGuildEntry, i as normalizeDiscordAllowList, k as resolveDiscordEndpointMediaGuard, l as resolveDiscordChannelConfigWithFallback, n as allowListMatches, o as normalizeDiscordSlug, p as resolveDiscordMemberAccessState, r as isDiscordGroupAllowedByPolicy, t as isDiscordThreadChannelType } from "./channel-type-DRCrEMss.mjs";
-import { a as listEnabledDiscordAccounts, c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-ChaMcixG.mjs";
+import { _ as DiscordError, ct as createThread, ft as getChannelMessage, t as discord_exports } from "./discord-J7aRzq2Q.mjs";
+import { A as resolveDiscordEndpointMediaGuard, O as getDiscordEndpointRuntime, a as normalizeDiscordAllowList, i as isDiscordGroupAllowedByPolicy, m as resolveDiscordMemberAccessState, n as allowListMatches, p as resolveDiscordGuildEntry, r as hasConfiguredDiscordChannels, s as normalizeDiscordSlug, t as isDiscordThreadChannelType, u as resolveDiscordChannelConfigWithFallback } from "./channel-type-D1_b5UhU.mjs";
+import { a as listEnabledDiscordAccounts, c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-DXHCL8Zm.mjs";
 import { t as resolveDiscordCommandOwnerAllowFrom } from "./command-owners-D78sAoOz.mjs";
-import { a as resolveDiscordChannelParentSafe, i as resolveDiscordChannelParentIdSafe, n as resolveDiscordChannelInfoSafe, r as resolveDiscordChannelNameSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.mjs";
-import { ComponentType, StickerFormatType } from "discord-api-types/v10";
+import { a as resolveDiscordChannelParentSafe, i as resolveDiscordChannelParentIdSafe, n as resolveDiscordChannelInfoSafe, r as resolveDiscordChannelNameSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-BRp3Y-rF.mjs";
+import { l as withAbortTimeout } from "./timeouts-pun7VJ02.mjs";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId, summarizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { ComponentType, Routes, StickerFormatType } from "discord-api-types/v10";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/ssrf-runtime";
 import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { buildAgentSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId, summarizeStringEntries, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getFileExtension, normalizeMimeType } from "openclaw/plugin-sdk/media-mime";
 import { createSubsystemLogger, getChildLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -95,14 +96,13 @@ async function generateThreadTitle(params) {
 			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,
+			timeoutMs: Math.max(100, Math.floor(params.timeoutMs ?? DEFAULT_THREAD_TITLE_TIMEOUT_MS)),
 			maxLength: MAX_THREAD_TITLE_SOURCE_CHARS
 		});
 		return generated ? normalizeGeneratedThreadTitle(generated) : null;
@@ -125,20 +125,8 @@ 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);
+	return stripThreadTitleWrappers(raw.replace(/\r/g, "").split("\n").find((line) => line.trim() && !line.trim().startsWith("```")) ?? "");
 }
 function stripThreadTitleWrappers(raw) {
 	let current = raw.trim();
@@ -155,11 +143,9 @@ function stripThreadTitleWrappers(raw) {
 	return current;
 }
 function stripBalancedWrapper(text, marker) {
-	if (text.length < marker.length * 2 + 1) return text;
-	if (!text.startsWith(marker) || !text.endsWith(marker)) return text;
+	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);
-	if (!inner || inner.includes(marker)) return text;
-	return inner;
+	return inner.includes(marker) ? text : inner;
 }
 function normalizeTitleContextField(raw, maxChars) {
 	const value = raw?.trim();
@@ -351,41 +337,22 @@ async function resolveReferencedReplyMediaList(message, maxBytes, options) {
 	const referencedReply = resolveDiscordReferencedReplyMessage(message);
 	return referencedReply ? resolveMessageMedia(referencedReply, createDiscordMediaOperation(maxBytes, options), "discord: failed to download referenced reply") : [];
 }
-async function fetchDiscordMedia(params) {
-	const endpointGuard = resolveDiscordEndpointMediaGuard(params.url, params.endpointRuntime);
-	const timeoutAbortController = params.totalTimeoutMs ? new AbortController() : void 0;
-	const signal = params.abortSignal && timeoutAbortController ? AbortSignal.any([params.abortSignal, timeoutAbortController.signal]) : params.abortSignal ?? timeoutAbortController?.signal;
-	let timedOut = false;
-	let timeoutHandle = null;
-	const savePromise = saveRemoteMedia({
-		url: params.url,
-		filePathHint: params.filePathHint,
-		maxBytes: params.maxBytes,
-		fetchImpl: endpointGuard ? void 0 : params.fetchImpl,
-		ssrfPolicy: endpointGuard?.ssrfPolicy ?? params.ssrfPolicy,
+async function fetchDiscordMedia(operation, params) {
+	const endpointGuard = resolveDiscordEndpointMediaGuard(params.url, operation.endpointRuntime);
+	const save = (signal) => saveRemoteMedia({
+		...params,
+		maxBytes: operation.maxBytes,
+		fetchImpl: endpointGuard ? void 0 : operation.fetchImpl,
+		ssrfPolicy: endpointGuard?.ssrfPolicy ?? operation.ssrfPolicy,
 		...endpointGuard ? { maxRedirects: endpointGuard.maxRedirects } : {},
-		readIdleTimeoutMs: params.readIdleTimeoutMs,
-		fallbackContentType: params.fallbackContentType,
-		originalFilename: params.originalFilename,
+		readIdleTimeoutMs: operation.readIdleTimeoutMs,
 		...signal ? { requestInit: { signal } } : {}
-	}).catch((error) => {
-		if (timedOut) return new Promise(() => {});
-		throw error;
 	});
-	try {
-		if (!params.totalTimeoutMs) return await savePromise;
-		const timeoutPromise = new Promise((_, reject) => {
-			timeoutHandle = setTimeout(() => {
-				timedOut = true;
-				timeoutAbortController?.abort();
-				reject(/* @__PURE__ */ new Error(`discord media download timed out after ${params.totalTimeoutMs}ms`));
-			}, params.totalTimeoutMs);
-			timeoutHandle.unref?.();
-		});
-		return await Promise.race([savePromise, timeoutPromise]);
-	} finally {
-		if (timeoutHandle) clearTimeout(timeoutHandle);
-	}
+	return operation.totalTimeoutMs ? withAbortTimeout({
+		timeoutMs: operation.totalTimeoutMs,
+		createTimeoutError: () => /* @__PURE__ */ new Error(`discord media download timed out after ${operation.totalTimeoutMs}ms`),
+		run: (signal) => save(operation.abortSignal ? AbortSignal.any([operation.abortSignal, signal]) : signal)
+	}) : save(operation.abortSignal);
 }
 async function appendResolvedMediaFromAttachments(params) {
 	const attachments = params.attachments;
@@ -398,16 +365,9 @@ async function appendResolvedMediaFromAttachments(params) {
 			continue;
 		}
 		try {
-			const saved = await fetchDiscordMedia({
+			const saved = await fetchDiscordMedia(params, {
 				url: attachmentUrl,
 				filePathHint: attachment.filename ?? attachmentUrl,
-				maxBytes: params.maxBytes,
-				fetchImpl: params.fetchImpl,
-				ssrfPolicy: params.ssrfPolicy,
-				readIdleTimeoutMs: params.readIdleTimeoutMs,
-				totalTimeoutMs: params.totalTimeoutMs,
-				abortSignal: params.abortSignal,
-				endpointRuntime: params.endpointRuntime,
 				fallbackContentType: attachment.content_type,
 				originalFilename: attachment.filename
 			});
@@ -423,8 +383,7 @@ async function appendResolvedMediaFromAttachments(params) {
 		} catch (err) {
 			const id = attachment.id ?? attachmentUrl;
 			getChildLogger({ module: "discord-media" }).warn(`${params.errorPrefix} ${id}: ${String(err)}`);
-			const classification = resolveDiscordMediaClassification({ attachment });
-			params.out.push({ ...classification });
+			params.out.push(resolveDiscordMediaClassification({ attachment }));
 		}
 	}
 }
@@ -473,16 +432,9 @@ async function appendResolvedMediaFromStickers(params) {
 		const candidates = resolveStickerAssetCandidates(sticker);
 		let lastError;
 		for (const candidate of candidates) try {
-			const saved = await fetchDiscordMedia({
+			const saved = await fetchDiscordMedia(params, {
 				url: candidate.url,
 				filePathHint: candidate.fileName,
-				maxBytes: params.maxBytes,
-				fetchImpl: params.fetchImpl,
-				ssrfPolicy: params.ssrfPolicy,
-				readIdleTimeoutMs: params.readIdleTimeoutMs,
-				totalTimeoutMs: params.totalTimeoutMs,
-				abortSignal: params.abortSignal,
-				endpointRuntime: params.endpointRuntime,
 				fallbackContentType: inferStickerContentType(sticker),
 				originalFilename: candidate.fileName
 			});
@@ -499,7 +451,7 @@ async function appendResolvedMediaFromStickers(params) {
 		}
 		if (lastError) {
 			getChildLogger({ module: "discord-media" }).warn(`${params.errorPrefix} ${sticker.id}: ${formatStickerError(lastError)}`);
-			if (candidates[0]) params.out.push({
+			params.out.push({
 				contentType: inferStickerContentType(sticker),
 				kind: "sticker"
 			});
@@ -768,7 +720,7 @@ function resolveDiscordReplyTarget(opts) {
 }
 function sanitizeDiscordThreadName(rawName, fallbackId) {
 	const baseSource = rawName.replace(/<@!?\d+>/g, "").replace(/<@&\d+>/g, "").replace(/<#\d+>/g, "").replace(/\s+/g, " ").trim() || `Thread ${fallbackId}`;
-	return truncateUtf16Safe(baseSource, 80) || `Thread ${fallbackId}`;
+	return truncateUtf16Safe(baseSource, 80);
 }
 function resolveDiscordReplyDeliveryPlan(params) {
 	const deliverTarget = params.createdThreadId ? `channel:${params.createdThreadId}` : params.replyTarget;
@@ -936,7 +888,7 @@ async function maybeRenameDiscordAutoThread(params) {
 		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 } });
+		await params.client.rest.patch(Routes.channel(params.threadId), { body: { name: nextName } });
 	} catch (err) {
 		logVerbose(`discord: autoThread rename failed for ${params.threadId}: ${String(err)}`);
 	}
@@ -1088,7 +1040,7 @@ async function authorizeDiscordVoiceIngress(initialParams) {
 		ok: false,
 		message: "This channel is disabled."
 	};
-	const channelAllowlistConfigured = Boolean(guildInfo?.channels) && Object.keys(guildInfo?.channels ?? {}).length > 0;
+	const channelAllowlistConfigured = hasConfiguredDiscordChannels(guildInfo?.channels);
 	if (!params.channelId && groupPolicy === "allowlist" && channelAllowlistConfigured) return {
 		ok: false,
 		message: `${params.channelLabel ?? "This channel"} is not allowlisted for voice commands.`

package/dist/.setup/typing-CNlSKY5S.mjs

@@ -0,0 +1,11 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { Routes } from "discord-api-types/v10";
+import { raceWithTimeout } from "openclaw/plugin-sdk/time-runtime";
+//#region extensions/discord/src/monitor/typing.ts
+var typing_exports = /* @__PURE__ */ __exportAll({ sendTyping: () => sendTyping });
+const DISCORD_TYPING_START_TIMEOUT_MS = 5e3;
+async function sendTyping(params) {
+	if ((await raceWithTimeout(params.rest.post(Routes.channelTyping(params.channelId)).then(() => ({ kind: "sent" })), DISCORD_TYPING_START_TIMEOUT_MS, () => ({ kind: "timeout" }), { ref: false })).kind === "timeout") throw new Error(`discord typing start timed out after ${DISCORD_TYPING_START_TIMEOUT_MS}ms`);
+}
+//#endregion
+export { typing_exports as n, sendTyping as t };