@openclaw/discord 2026.10.5 → 2026.10.10-beta.2

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

@@ -5,8 +5,8 @@ import { asOptionalObjectRecord, normalizeLowercaseStringOrEmpty, normalizeOptio
 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";
+import { resolveThreadBindingExpiry, warnPluginSdkDeprecation } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 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() {
@@ -21,7 +21,6 @@ function createThreadBindingsGlobalState() {
 		loadedPersistentBindings: false,
 		persistenceAvailable: true,
 		lastPersistedAtMs: 0,
-		revision: 0,
 		mutationTail: Promise.resolve(),
 		accountOperationTails: /* @__PURE__ */ new WeakMap()
 	};
@@ -59,7 +58,7 @@ function openThreadBindingsStore() {
 	});
 }
 function openThreadBindingsStoreAsync() {
-	return getDiscordRuntime().state.openKeyedStore({
+	return getDiscordRuntime().state.openKeyedStoreV2({
 		namespace: THREAD_BINDINGS_NAMESPACE,
 		maxEntries: THREAD_BINDINGS_MAX_ENTRIES
 	});
@@ -200,7 +199,6 @@ function setBindingRecord(record) {
 	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);
 }
@@ -210,14 +208,12 @@ function removeBindingRecord(bindingKeyRaw) {
 	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;
@@ -317,13 +313,12 @@ function drainThreadBindingMutations() {
 	return THREAD_BINDINGS_STATE.mutationTail;
 }
 async function commitBindingRecord(params) {
-	const revision = THREAD_BINDINGS_STATE.revision;
 	let authorityRefused = false;
 	let targetCommitted = false;
+	let committedWrites = 0;
 	const assertCurrent = () => {
 		try {
 			params.assertCurrent?.();
-			if (THREAD_BINDINGS_STATE.revision !== revision || BINDINGS_BY_THREAD_ID.get(params.bindingKey) !== params.previous) throw new Error("Discord thread binding changed during persistence");
 		} catch (error) {
 			authorityRefused = true;
 			throw error;
@@ -335,34 +330,21 @@ async function commitBindingRecord(params) {
 		const records = new Map(BINDINGS_BY_THREAD_ID);
 		if (params.next) records.set(params.bindingKey, params.next);
 		else records.delete(params.bindingKey);
-		const active = {
-			targetKey: params.bindingKey,
-			deletingTarget: params.next === null,
-			nextRecord: params.next,
-			writingKey: void 0,
-			committedKeys: /* @__PURE__ */ new Set()
-		};
-		THREAD_BINDINGS_STATE.activePersistence = active;
 		try {
 			const store = openThreadBindingsStoreAsync();
 			for (const [key, record] of records) {
 				assertCurrent();
 				const persisted = toPersistedBindingRecord(record);
-				if (key === params.bindingKey) active.nextRecord = persisted;
-				active.writingKey = key;
 				await store.register(key, persisted, { assertCurrent });
-				active.writingKey = void 0;
-				active.committedKeys.add(key);
+				committedWrites += 1;
 				targetCommitted ||= key === params.bindingKey;
 			}
 			assertCurrent();
 			const entries = await store.entries();
 			assertCurrent();
 			for (const entry of entries) if (!records.has(entry.key)) {
-				active.writingKey = entry.key;
 				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;
@@ -370,7 +352,6 @@ 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();
@@ -390,8 +371,6 @@ async function commitBindingRecord(params) {
 				THREAD_BINDINGS_STATE.persistenceAvailable = false;
 				logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
 			}
-		} finally {
-			delete THREAD_BINDINGS_STATE.activePersistence;
 		}
 	}
 	if (!targetCommitted) assertCurrent();
@@ -399,38 +378,17 @@ async function commitBindingRecord(params) {
 	if (params.next) setBindingRecord(params.next);
 	else removeBindingRecord(params.bindingKey);
 }
-function persistBindingsSync(update, removedKey) {
+function persistBindingsSync(update) {
 	const store = openThreadBindingsStore();
-	const active = THREAD_BINDINGS_STATE.activePersistence;
 	let updatedRecord;
-	for (const [key, record] of BINDINGS_BY_THREAD_ID) if (key === update?.bindingKey || active?.targetKey === key && active.deletingTarget || active?.writingKey === key || active?.committedKeys.has(key)) {
+	for (const [key, record] of BINDINGS_BY_THREAD_ID) if (key === update?.bindingKey) {
 		if (!store.update) throw new Error("Discord synchronous compatibility requires atomic state update");
-		let next;
-		store.update(key, (current) => {
-			let base = record;
-			if (active?.targetKey === key) {
-				if (!current && active.deletingTarget) base = void 0;
-				else if (current && active.nextRecord && (active.writingKey === key || active.committedKeys.has(key)) && JSON.stringify(toPersistedBindingRecord(current)) === JSON.stringify(toPersistedBindingRecord(active.nextRecord))) base = normalizePersistedBinding(key, current) ?? record;
-			}
-			if (key === update?.bindingKey) update.observe?.(current && normalizePersistedBinding(key, current) ? base : void 0);
-			next = base ? key === update?.bindingKey ? update.transform(base) : base : void 0;
-			return next ? toPersistedBindingRecord(next) : void 0;
-		});
-		if (key === update?.bindingKey) updatedRecord = next;
-		if (next) {
-			if (next !== record) setBindingRecord(next);
-		} else if (!(active?.targetKey === key && active.deletingTarget)) removeBindingRecord(key);
+		const next = update.transform(record);
+		store.update(key, () => toPersistedBindingRecord(next));
+		updatedRecord = next;
+		if (next !== record) setBindingRecord(next);
 	} else store.register(key, toPersistedBindingRecord(record));
-	for (const entry of store.entries()) if (!BINDINGS_BY_THREAD_ID.has(entry.key)) {
-		if (entry.key !== removedKey && active?.targetKey === entry.key && !active.deletingTarget) {
-			const committed = normalizePersistedBinding(entry.key, entry.value);
-			if (committed) {
-				setBindingRecord(committed);
-				continue;
-			}
-		}
-		store.delete(entry.key);
-	}
+	for (const entry of store.entries()) if (!BINDINGS_BY_THREAD_ID.has(entry.key)) store.delete(entry.key);
 	THREAD_BINDINGS_STATE.loadedPersistentBindings = BINDINGS_BY_THREAD_ID.size > 0;
 	THREAD_BINDINGS_STATE.lastPersistedAtMs = Date.now();
 	return updatedRecord;
@@ -440,76 +398,36 @@ function updateBindingRecordSync(params) {
 	const record = BINDINGS_BY_THREAD_ID.get(params.bindingKey);
 	if (!record) return null;
 	const now = Date.now();
-	const persist = params.persist && THREAD_BINDINGS_STATE.persistenceAvailable && (THREAD_BINDINGS_STATE.activePersistence || !params.minIntervalMs || now - THREAD_BINDINGS_STATE.lastPersistedAtMs >= params.minIntervalMs);
-	let observed;
-	if (persist) try {
-		return persistBindingsSync({
-			...params,
-			observe: (current) => {
-				observed = current;
-			}
-		}) ?? null;
+	if (params.persist && THREAD_BINDINGS_STATE.persistenceAvailable && (!params.minIntervalMs || now - THREAD_BINDINGS_STATE.lastPersistedAtMs >= params.minIntervalMs)) try {
+		return persistBindingsSync(params) ?? null;
 	} catch {
 		THREAD_BINDINGS_STATE.persistenceAvailable = false;
 		logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
 	}
 	const current = BINDINGS_BY_THREAD_ID.get(params.bindingKey);
 	if (current !== record) return current ?? null;
-	if (THREAD_BINDINGS_STATE.activePersistence?.targetKey === params.bindingKey && !observed) {
-		logVerbose("discord synchronous binding update skipped: pending target read unavailable");
-		return null;
-	}
-	const next = params.transform(observed ?? record);
+	const next = params.transform(record);
 	setBindingRecord(next);
 	return next;
 }
 /** Public SDK compatibility only; bundled callers await worker mutations. */
 function removeBindingRecordSync(bindingKey) {
-	const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
-	if (!record) return null;
-	if (!shouldPersistBindingMutations() || !THREAD_BINDINGS_STATE.persistenceAvailable) return THREAD_BINDINGS_STATE.activePersistence?.targetKey === bindingKey ? null : removeBindingRecord(bindingKey);
+	if (!BINDINGS_BY_THREAD_ID.get(bindingKey)) return null;
+	if (!shouldPersistBindingMutations() || !THREAD_BINDINGS_STATE.persistenceAvailable) return removeBindingRecord(bindingKey);
 	let removed = null;
-	let observed = null;
-	let replacement;
 	try {
-		const store = openThreadBindingsStore();
-		if (!store.deleteIf) throw new Error("Discord synchronous compatibility requires atomic state deletion");
-		const deleted = store.deleteIf(bindingKey, (current) => {
-			const normalized = normalizePersistedBinding(bindingKey, current);
-			observed = normalized;
-			const pending = THREAD_BINDINGS_STATE.activePersistence;
-			if (normalized && pending?.targetKey === bindingKey && pending.nextRecord && (pending.writingKey === bindingKey || pending.committedKeys.has(bindingKey)) && JSON.stringify(toPersistedBindingRecord(normalized)) === JSON.stringify(toPersistedBindingRecord(pending.nextRecord)) && (normalized.targetSessionKey !== record.targetSessionKey || normalized.targetKind !== record.targetKind)) {
-				replacement = normalized;
-				return false;
-			}
-			return true;
-		});
-		if (replacement) {
-			setBindingRecord(replacement);
-			return null;
-		}
-		const pending = THREAD_BINDINGS_STATE.activePersistence;
-		if (!deleted && pending?.targetKey === bindingKey && pending.deletingTarget) return null;
+		openThreadBindingsStore().delete(bindingKey);
 		removed = removeBindingRecord(bindingKey);
-		persistBindingsSync(void 0, bindingKey);
+		persistBindingsSync();
 		return removed;
 	} catch {
 		THREAD_BINDINGS_STATE.persistenceAvailable = false;
-		if (replacement) {
-			setBindingRecord(replacement);
-			return null;
-		}
-		if (THREAD_BINDINGS_STATE.activePersistence?.targetKey === bindingKey && !observed && !removed) {
-			logVerbose("discord synchronous binding removal skipped: pending target read unavailable");
-			return null;
-		}
 		return removed ?? removeBindingRecord(bindingKey);
 	}
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
 function resolveBindingIdsForTargetSession(params) {
-	ensureBindingsLoaded();
 	return resolveBindingIdsForSession({
 		...params,
 		accountId: params.accountId ? normalizeAccountId(params.accountId) : void 0
@@ -517,41 +435,33 @@ function resolveBindingIdsForTargetSession(params) {
 }
 function mutateBindingsForTargetSession(params, update, onRemoved) {
 	const accountId = params.accountId ? normalizeAccountId(params.accountId) : void 0;
-	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 () => {
+	const managers = [];
+	const stoppingAtAdmission = /* @__PURE__ */ new Map();
+	for (const [ownerAccountId, manager] of MANAGERS_BY_ACCOUNT_ID) if (accountId === void 0 || ownerAccountId === accountId) {
+		managers.push(manager);
+		stoppingAtAdmission.set(ownerAccountId, manager.isStopping());
+	}
+	return runThreadBindingAccountOperation(managers, () => runThreadBindingMutation(async () => {
 		await ensureBindingsLoadedAsync();
 		const ids = resolveBindingIdsForTargetSession(params);
-		const owners = /* @__PURE__ */ new Map();
 		for (const bindingKey of ids) {
 			const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
 			if (!existing) continue;
 			const manager = MANAGERS_BY_ACCOUNT_ID.get(existing.accountId);
-			const admitted = admittedOwners.get(existing.accountId);
-			if (admitted?.stopping || !admitted && manager?.isStopping()) throw new Error("Discord thread binding manager is stopping");
-			if (admitted?.manager !== manager) throw new Error("Discord thread binding manager changed");
-			owners.set(existing.accountId, manager);
+			if (stoppingAtAdmission.get(existing.accountId) ?? manager?.isStopping()) throw new Error("Discord thread binding manager is stopping");
 		}
 		const now = Date.now();
 		const updated = [];
 		for (const bindingKey of ids) {
 			const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
 			if (!existing) continue;
-			const manager = owners.get(existing.accountId);
-			const assertCurrent = () => {
-				if (MANAGERS_BY_ACCOUNT_ID.get(existing.accountId) !== manager) throw new Error("Discord thread binding manager changed");
-			};
+			const manager = MANAGERS_BY_ACCOUNT_ID.get(existing.accountId);
 			const nextRecord = update(existing, now);
 			await commitBindingRecord({
 				bindingKey,
 				previous: existing,
 				next: nextRecord,
-				persist: shouldPersistBindingMutations(),
-				assertCurrent
+				persist: shouldPersistBindingMutations()
 			});
 			if (!nextRecord) onRemoved?.(existing, manager);
 			updated.push(nextRecord ?? existing);
@@ -594,6 +504,13 @@ function createDurationSetters(field) {
 			return mutateBindingsForTargetSession(params, createDurationUpdate(field, params[field]));
 		},
 		set: (params) => {
+			const method = field === "idleTimeoutMs" ? "setThreadBindingIdleTimeoutBySessionKey" : "setThreadBindingMaxAgeBySessionKey";
+			warnPluginSdkDeprecation({
+				family: "conversation-bindings",
+				method,
+				replacement: `${method}Async`
+			});
+			ensureBindingsLoaded();
 			return updateBindingsForTargetSessionSync(resolveBindingIdsForTargetSession(params), createDurationUpdate(field, params[field]));
 		}
 	};
@@ -602,9 +519,9 @@ 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. */
+/** @deprecated Use setThreadBindingIdleTimeoutBySessionKeyAsync; compatible through 2026-12-31, removed in the first January 2027 stable. */
 const setThreadBindingIdleTimeoutBySessionKey = idleSetters.set;
-/** @deprecated Use the awaited lifecycle setter; retained for the generic SDK contract. */
+/** @deprecated Use setThreadBindingMaxAgeBySessionKeyAsync; compatible through 2026-12-31, removed in the first January 2027 stable. */
 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, 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 };
+export { resolveBindingIdsForSession as A, forgetThreadBindingToken as C, refreshUnboundThreadWebhookIdentity as D, normalizeThreadBindingDurationMs as E, resolveThreadBindingMaxAgeExpiresAt as F, resolveThreadBindingMaxAgeMs as I, shouldDefaultPersist as L, resolvePreparedThreadBindingLifecycle as M, resolveThreadBindingIdleTimeoutMs as N, rememberReusableWebhook as O, resolveThreadBindingInactivityExpiresAt as P, toBindingRecordKey as R, ensureBindingsLoadedAsync as S, normalizeTargetKind 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, resolveBindingRecordKey as j, rememberThreadBindingToken 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, getThreadBindingToken as w, ensureBindingsLoaded as x, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as y, toReusableWebhookKey as z };

package/dist/.setup/{threading-BWz5lW0p.mjs → threading-Cg_QRc8s.mjs}

@@ -1,6 +1,6 @@
 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-EMrQb132.mjs";
+import { lt as createThread, pt as getChannelMessage, t as discord_exports } from "./discord-Cl2OPTZ6.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-fRvFsZng.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";

package/dist/.setup/{transcripts-source-EMrQb132.mjs → transcripts-source-fRvFsZng.mjs}

@@ -1,8 +1,8 @@
 import { l as resolveDiscordAccount, o as listEnabledDiscordAccounts, u as resolveDiscordAccountAllowFrom } from "./accounts-ljrzXBJi.mjs";
 import { A as isDiscordThreadChannelType, D as getDiscordEndpointRuntime, f as resolveDiscordGuildEntry, i as normalizeDiscordAllowList, k as resolveDiscordEndpointMediaGuard, l as resolveDiscordChannelConfigWithFallback, n as hasConfiguredDiscordChannels, o as normalizeDiscordSlug, p as resolveDiscordMemberAccessState, r as isDiscordGroupAllowedByPolicy, t as allowListMatches } from "./allow-list-B_ToXtew.mjs";
-import { L as DiscordError, ft as getChannelMessage, t as discord_exports } from "./discord-BGqgx-yd.mjs";
+import { L as DiscordError, pt as getChannelMessage, t as discord_exports } from "./discord-Cl2OPTZ6.mjs";
 import { l as withAbortTimeout } from "./timeouts-CuNARfyw.mjs";
-import { t as resolveDiscordCommandOwnerAllowFrom } from "./command-owners-C7rUdqUX.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-DasWY_OV.mjs";
 import { createSubsystemLogger, getChildLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
@@ -10,7 +10,6 @@ import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOpti
 import { ComponentType, StickerFormatType } from "discord-api-types/v10";
 import { pruneMapToMaxSize } from "openclaw/plugin-sdk/collection-runtime";
 import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
-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 { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
@@ -27,14 +26,11 @@ const DISCORD_CHANNEL_INFO_CACHE_TTL_MS = 3e5;
 const DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS = 3e4;
 const DISCORD_CHANNEL_INFO_CACHE_MAX_ENTRIES = 1e3;
 function cacheDiscordChannelInfo(channelId, value, ttlMs, nowMs) {
-	const expiresAt = resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs });
-	if (expiresAt !== void 0) {
-		discordChannelInfoCacheState.entries.set(channelId, {
-			value,
-			expiresAt
-		});
-		pruneMapToMaxSize(discordChannelInfoCacheState.entries, DISCORD_CHANNEL_INFO_CACHE_MAX_ENTRIES);
-	}
+	discordChannelInfoCacheState.entries.set(channelId, {
+		value,
+		expiresAt: nowMs + ttlMs
+	});
+	pruneMapToMaxSize(discordChannelInfoCacheState.entries, DISCORD_CHANNEL_INFO_CACHE_MAX_ENTRIES);
 }
 function normalizeDiscordChannelId(value) {
 	return normalizeOptionalStringifiedId(value) ?? "";
@@ -55,26 +51,25 @@ function buildDiscordChannelInfo(channel, options) {
 	};
 }
 async function resolveDiscordChannelInfo(client, channelId) {
-	const rawNow = Date.now();
-	const now = asDateTimestampMs(rawNow);
+	const now = Date.now();
 	const cached = discordChannelInfoCacheState.entries.get(channelId);
 	if (cached) {
-		if (now !== void 0 && cached.expiresAt > now) return cached.value;
+		if (cached.expiresAt > now) return cached.value;
 		discordChannelInfoCacheState.entries.delete(channelId);
 	}
 	try {
 		const channel = await client.fetchChannel(channelId);
 		if (!channel) {
-			cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, rawNow);
+			cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, now);
 			return null;
 		}
 		const payload = buildDiscordChannelInfo(channel, { rawTypeFallback: true });
 		if (!payload) return null;
-		cacheDiscordChannelInfo(channelId, payload, DISCORD_CHANNEL_INFO_CACHE_TTL_MS, rawNow);
+		cacheDiscordChannelInfo(channelId, payload, DISCORD_CHANNEL_INFO_CACHE_TTL_MS, now);
 		return payload;
 	} catch (err) {
 		logVerbose(`discord: failed to fetch channel ${channelId}: ${String(err)}`);
-		cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, rawNow);
+		cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, now);
 		return null;
 	}
 }