@openclaw/discord 2026.7.2-beta.7 → 2026.8.1-beta.2

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

@@ -1,13 +1,251 @@
-import { Yt as __exportAll, u as resolveDiscordChannelId, yt as getChannel } from "./chunk-DX4jpFQP.js";
-import { F as createDiscordRestClient } from "./send.shared-jpvAG_u6.js";
-import { C as resolveThreadBindingInactivityExpiresAt, D as setBindingRecord, E as saveBindingsToDisk, O as shouldDefaultPersist, S as resolveThreadBindingIdleTimeoutMs$1, T as resolveThreadBindingMaxAgeMs$1, _ as rememberThreadBindingToken, b as resolveBindingIdsForSession, c as ensureBindingsLoaded, f as normalizeTargetKind, h as refreshUnboundThreadWebhookIdentity, 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 resolveThreadBindingMaxAgeExpiresAt, x as resolveBindingRecordKey, y as resetThreadBindingsForTests } from "./thread-bindings.state-Cgi5uRn-.js";
-import { S as resolveThreadBindingThreadName, a as isThreadArchived, b as resolveThreadBindingFarewellText, c as summarizeDiscordError, i as isDiscordThreadGoneError, l as DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS, n as createWebhookForChannel, o as maybeSendBindingMessage, r as findReusableWebhook, s as resolveChannelIdForBinding, t as createThreadForBinding, u as THREAD_BINDINGS_SWEEP_INTERVAL_MS } from "./thread-bindings.discord-api-BoDNqamb.js";
-import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
+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 { 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 { registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
-import { resolveDefaultAgentId } from "openclaw/plugin-sdk/agent-runtime";
+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";
+//#region extensions/discord/src/monitor/thread-bindings.persona.ts
+const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
+function normalizePersonaLabel(value) {
+	if (!value) return;
+	return value.replace(/\s+/g, " ").trim() || void 0;
+}
+function resolveThreadBindingPersona(params) {
+	return truncateUtf16Safe(`${SYSTEM_MARK} ${normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent"}`, THREAD_BINDING_PERSONA_MAX_CHARS);
+}
+function resolveThreadBindingPersonaFromRecord(record) {
+	return resolveThreadBindingPersona({
+		label: record.label,
+		agentId: record.agentId
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/channel-access.ts
+function readDiscordChannelPropertySafe(channel, key) {
+	if (!channel || typeof channel !== "object") return;
+	try {
+		if (!(key in channel)) return;
+		return channel[key];
+	} catch {
+		return;
+	}
+}
+function resolveDiscordChannelStringPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "string" ? value : void 0;
+}
+function resolveDiscordChannelNumberPropertySafe(channel, key) {
+	const value = readDiscordChannelPropertySafe(channel, key);
+	return typeof value === "number" ? value : void 0;
+}
+const DISCORD_CHANNEL_SNAKE_CASE_ALIASES = {
+	ownerId: "owner_id",
+	parentId: "parent_id"
+};
+function resolveDiscordChannelStringWithAliasSafe(channel, camelKey) {
+	const camelValue = resolveDiscordChannelStringPropertySafe(channel, camelKey);
+	if (camelValue !== void 0) return camelValue;
+	const snakeKey = DISCORD_CHANNEL_SNAKE_CASE_ALIASES[camelKey];
+	if (!snakeKey) return;
+	const directSnakeValue = resolveDiscordChannelStringPropertySafe(channel, snakeKey);
+	if (directSnakeValue !== void 0) return directSnakeValue;
+	return resolveDiscordChannelStringPropertySafe(readDiscordChannelPropertySafe(channel, "rawData"), snakeKey);
+}
+function resolveDiscordChannelNameSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "name");
+}
+function resolveDiscordChannelIdSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "id");
+}
+function resolveDiscordChannelTopicSafe(channel) {
+	return resolveDiscordChannelStringPropertySafe(channel, "topic");
+}
+function resolveDiscordChannelParentIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "parentId");
+}
+function resolveDiscordChannelOwnerIdSafe(channel) {
+	return resolveDiscordChannelStringWithAliasSafe(channel, "ownerId");
+}
+function resolveDiscordChannelParentSafe(channel) {
+	return readDiscordChannelPropertySafe(channel, "parent");
+}
+function resolveDiscordChannelInfoSafe(channel) {
+	const parent = resolveDiscordChannelParentSafe(channel);
+	return {
+		name: resolveDiscordChannelNameSafe(channel),
+		topic: resolveDiscordChannelTopicSafe(channel),
+		type: resolveDiscordChannelNumberPropertySafe(channel, "type"),
+		parentId: resolveDiscordChannelParentIdSafe(channel),
+		ownerId: resolveDiscordChannelOwnerIdSafe(channel),
+		parentName: resolveDiscordChannelNameSafe(parent)
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.types.ts
+const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 12e4;
+const DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS = 1440 * 60 * 1e3;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.discord-api.ts
+function buildThreadTarget(threadId) {
+	return /^(channel:|user:)/i.test(threadId) ? threadId : `channel:${threadId}`;
+}
+function isThreadArchived(raw) {
+	if (!raw || typeof raw !== "object") return false;
+	const asRecord = raw;
+	if (asRecord.archived === true) return true;
+	if (asRecord.thread_metadata?.archived === true) return true;
+	if (asRecord.threadMetadata?.archived === true) return true;
+	return false;
+}
+function isThreadChannelType(type) {
+	return type === ChannelType.PublicThread || type === ChannelType.PrivateThread || type === ChannelType.AnnouncementThread;
+}
+function normalizeDiscordBindingChannelId(raw) {
+	const trimmed = normalizeOptionalString(raw) ?? "";
+	if (!trimmed) return null;
+	try {
+		return resolveDiscordChannelId(trimmed);
+	} catch {
+		return null;
+	}
+}
+function summarizeDiscordError(err) {
+	if (err instanceof Error) return err.message;
+	if (typeof err === "string") return err;
+	if (typeof err === "number" || typeof err === "boolean" || typeof err === "bigint" || typeof err === "symbol") return String(err);
+	return "error";
+}
+function extractNumericDiscordErrorValue(value) {
+	return parseStrictNonNegativeInteger$1(value);
+}
+function extractDiscordErrorStatus(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.status) ?? extractNumericDiscordErrorValue(candidate.statusCode) ?? extractNumericDiscordErrorValue(candidate.response?.status);
+}
+function extractDiscordErrorCode(err) {
+	if (!err || typeof err !== "object") return;
+	const candidate = err;
+	return extractNumericDiscordErrorValue(candidate.code) ?? extractNumericDiscordErrorValue(candidate.rawError?.code) ?? extractNumericDiscordErrorValue(candidate.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.body?.code) ?? extractNumericDiscordErrorValue(candidate.response?.data?.code);
+}
+function isDiscordThreadGoneError(err) {
+	if (extractDiscordErrorCode(err) === 10003) return true;
+	const status = extractDiscordErrorStatus(err);
+	return status === 404 || status === 403;
+}
+async function maybeSendBindingMessage(params) {
+	const text = params.text.trim();
+	if (!text) return;
+	const record = params.record;
+	if (params.preferWebhook !== false && record.webhookId && record.webhookToken) try {
+		await sendWebhookMessageDiscord(text, {
+			cfg: params.cfg,
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken,
+			accountId: record.accountId,
+			threadId: record.threadId,
+			username: resolveThreadBindingPersonaFromRecord(record)
+		});
+		return;
+	} catch (err) {
+		logVerbose(`discord thread binding webhook send failed: ${summarizeDiscordError(err)}`);
+	}
+	try {
+		await sendMessageDiscord(buildThreadTarget(record.threadId), text, {
+			cfg: params.cfg,
+			accountId: record.accountId
+		});
+	} catch (err) {
+		logVerbose(`discord thread binding fallback send failed: ${summarizeDiscordError(err)}`);
+	}
+}
+async function createWebhookForChannel(params) {
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const created = await createChannelWebhook(rest, params.channelId, { body: { name: "OpenClaw Agents" } });
+		const webhookId = normalizeOptionalString(created?.id) ?? "";
+		const webhookToken = normalizeOptionalString(created?.token) ?? "";
+		if (!webhookId || !webhookToken) return {};
+		return {
+			webhookId,
+			webhookToken
+		};
+	} catch (err) {
+		logVerbose(`discord thread binding webhook create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return {};
+	}
+}
+function findReusableWebhook(params) {
+	const reusableKey = toReusableWebhookKey({
+		accountId: params.accountId,
+		channelId: params.channelId
+	});
+	const cached = REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.get(reusableKey);
+	if (cached) return {
+		webhookId: cached.webhookId,
+		webhookToken: cached.webhookToken
+	};
+	for (const record of BINDINGS_BY_THREAD_ID.values()) {
+		if (record.accountId !== params.accountId) continue;
+		if (record.channelId !== params.channelId) continue;
+		if (!record.webhookId || !record.webhookToken) continue;
+		rememberReusableWebhook(record);
+		return {
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken
+		};
+	}
+	return {};
+}
+async function resolveChannelIdForBinding(params) {
+	const explicit = normalizeDiscordBindingChannelId(params.channelId);
+	if (explicit) return explicit;
+	const lookupThreadId = normalizeDiscordBindingChannelId(params.threadId);
+	if (!lookupThreadId) return null;
+	try {
+		const rest = createDiscordRestClient({
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}).rest;
+		const channel = await getChannel(rest, lookupThreadId);
+		const channelInfo = resolveDiscordChannelInfoSafe(channel);
+		const channelId = normalizeOptionalString(resolveDiscordChannelIdSafe(channel)) ?? "";
+		const type = channelInfo.type;
+		const parentId = normalizeOptionalString(channelInfo.parentId) ?? "";
+		if (parentId && isThreadChannelType(type)) return parentId;
+		return channelId || null;
+	} catch (err) {
+		logVerbose(`discord thread binding channel resolve failed for ${lookupThreadId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+async function createThreadForBinding(params) {
+	try {
+		return (normalizeOptionalString((await createThreadDiscord(params.channelId, { name: params.threadName }, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		}))?.id) ?? "") || null;
+	} catch (err) {
+		logVerbose(`discord thread binding auto-thread create failed for ${params.channelId}: ${summarizeDiscordError(err)}`);
+		return null;
+	}
+}
+//#endregion
 //#region extensions/discord/src/monitor/thread-bindings.session-adapter.ts
 function normalizeChildBindingParentChannelId(raw) {
 	const trimmed = normalizeOptionalString(raw) ?? "";
@@ -77,7 +315,7 @@ function toSessionBindingRecord(record, defaults) {
 	};
 }
 function createThreadBindingSessionAdapter(params) {
-	const toRecord = (entry) => toSessionBindingRecord(entry, params.defaults);
+	const serializeBinding = (entry) => toSessionBindingRecord(entry, params.defaults);
 	return {
 		channel: "discord",
 		accountId: params.accountId,
@@ -120,13 +358,13 @@ function createThreadBindingSessionAdapter(params) {
 				introText,
 				metadata
 			});
-			return bound ? toRecord(bound) : null;
+			return bound ? serializeBinding(bound) : null;
 		},
-		listBySession: (targetSessionKey) => params.manager.listBySessionKey(targetSessionKey).map(toRecord),
+		listBySession: (targetSessionKey) => params.manager.listBySessionKey(targetSessionKey).map(serializeBinding),
 		resolveByConversation: (ref) => {
 			if (ref.channel !== "discord") return null;
 			const binding = params.manager.getByThreadId(ref.conversationId);
-			return binding ? toRecord(binding) : null;
+			return binding ? serializeBinding(binding) : null;
 		},
 		touch: (bindingId, at) => {
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
@@ -144,7 +382,7 @@ function createThreadBindingSessionAdapter(params) {
 			if (input.targetSessionKey?.trim()) return params.manager.unbindBySessionKey({
 				targetSessionKey: input.targetSessionKey,
 				reason: input.reason
-			}).map(toRecord);
+			}).map(serializeBinding);
 			const threadId = resolveThreadBindingConversationIdFromBindingId({
 				accountId: params.accountId,
 				bindingId: input.bindingId
@@ -154,18 +392,16 @@ function createThreadBindingSessionAdapter(params) {
 				threadId,
 				reason: input.reason
 			});
-			return removed ? [toRecord(removed)] : [];
+			return removed ? [serializeBinding(removed)] : [];
 		}
 	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/thread-bindings.manager.ts
 var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
-	__testing: () => testing,
 	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
 	createThreadBindingManager: () => createThreadBindingManager,
-	getThreadBindingManager: () => getThreadBindingManager,
-	testing: () => testing
+	getThreadBindingManager: () => getThreadBindingManager
 });
 function registerManager(manager) {
 	MANAGERS_BY_ACCOUNT_ID.set(manager.accountId, manager);
@@ -173,7 +409,6 @@ function registerManager(manager) {
 function unregisterManager(accountId, manager) {
 	if (MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager) MANAGERS_BY_ACCOUNT_ID.delete(accountId);
 }
-const SWEEPERS_BY_ACCOUNT_ID = /* @__PURE__ */ new Map();
 function createNoopManager(accountIdRaw) {
 	return {
 		accountId: normalizeAccountId(accountIdRaw),
@@ -297,7 +532,6 @@ function createThreadBindingManager(params) {
 			}
 		}
 	};
-	SWEEPERS_BY_ACCOUNT_ID.set(accountId, runSweepOnce);
 	const manager = {
 		accountId,
 		getIdleTimeoutMs: () => idleTimeoutMs,
@@ -400,7 +634,10 @@ function createThreadBindingManager(params) {
 				threadId,
 				targetKind,
 				targetSessionKey,
-				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveAgentIdFromSessionKey(targetSessionKey, resolveDefaultAgentId(cfg)),
+				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(existingValue?.agentId) ?? resolveSessionAgentId({
+					config: cfg,
+					sessionKey: targetSessionKey
+				}),
 				label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(existingValue?.label),
 				webhookId: webhookId || void 0,
 				webhookToken: webhookToken || void 0,
@@ -485,7 +722,6 @@ function createThreadBindingManager(params) {
 				clearInterval(sweepTimer);
 				sweepTimer = null;
 			}
-			SWEEPERS_BY_ACCOUNT_ID.delete(accountId);
 			unregisterManager(accountId, manager);
 			unregisterSessionBindingAdapter({
 				channel: "discord",
@@ -522,13 +758,5 @@ function getThreadBindingManager(accountId) {
 	const normalized = normalizeAccountId(accountId);
 	return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
 }
-const testing = {
-	resolveThreadBindingThreadName,
-	resetThreadBindingsForTests,
-	runThreadBindingSweepForAccount: async (accountId) => {
-		const sweep = SWEEPERS_BY_ACCOUNT_ID.get(normalizeAccountId(accountId));
-		if (sweep) await sweep();
-	}
-};
 //#endregion
-export { thread_bindings_manager_exports as a, testing as i, createThreadBindingManager as n, getThreadBindingManager as r, createNoopThreadBindingManager as t };
+export { resolveThreadBindingThreadName as _, isThreadArchived as a, resolveDiscordChannelInfoSafe as c, resolveDiscordChannelParentSafe as d, resolveDiscordChannelTopicSafe as f, resolveThreadBindingIntroText as g, formatThreadBindingDurationLabel as h, thread_bindings_manager_exports as i, resolveDiscordChannelNameSafe as l, resolveThreadBindingPersonaFromRecord as m, createThreadBindingManager as n, resolveChannelIdForBinding as o, resolveThreadBindingPersona as p, getThreadBindingManager as r, resolveDiscordChannelIdSafe as s, createNoopThreadBindingManager as t, resolveDiscordChannelParentIdSafe as u };

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

@@ -1,4 +1,4 @@
-import { D as setBindingRecord, E as saveBindingsToDisk, b as resolveBindingIdsForSession, c as ensureBindingsLoaded, k as shouldPersistBindingMutations, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-Cgi5uRn-.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-aeV8HNgV.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-Cgi5uRn-.js → thread-bindings.state-aeV8HNgV.js}

@@ -1,7 +1,7 @@
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
 import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/channel-outbound";
+import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/outbound-echo-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.state.ts
 const THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.discordThreadBindingsState");
 let threadBindingsState;
@@ -284,18 +284,5 @@ function resolveBindingIdsForSession(params) {
 	}
 	return out;
 }
-function resetThreadBindingsForTests() {
-	for (const manager of MANAGERS_BY_ACCOUNT_ID.values()) manager.stop();
-	MANAGERS_BY_ACCOUNT_ID.clear();
-	BINDINGS_BY_THREAD_ID.clear();
-	BINDINGS_BY_SESSION_KEY.clear();
-	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
-	TOKENS_BY_ACCOUNT_ID.clear();
-	PERSIST_BY_ACCOUNT_ID.clear();
-	THREAD_BINDINGS_STATE.loadedBindings = false;
-	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
-	THREAD_BINDINGS_STATE.persistenceAvailable = true;
-	THREAD_BINDINGS_STATE.lastPersistedAtMs = 0;
-}
 //#endregion
-export { toBindingRecordKey as A, resolveThreadBindingInactivityExpiresAt as C, setBindingRecord as D, saveBindingsToDisk as E, shouldDefaultPersist as O, resolveThreadBindingIdleTimeoutMs as S, resolveThreadBindingMaxAgeMs as T, rememberThreadBindingToken as _, THREAD_BINDINGS_MAX_ENTRIES as a, resolveBindingIdsForSession as b, ensureBindingsLoaded as c, normalizePersistedBinding as d, normalizeTargetKind as f, rememberReusableWebhook as g, refreshUnboundThreadWebhookIdentity as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toReusableWebhookKey as j, shouldPersistBindingMutations as k, forgetThreadBindingToken as l, normalizeThreadId as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizeThreadBindingDurationMs as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as s, BINDINGS_BY_THREAD_ID as t, getThreadBindingToken as u, removeBindingRecord as v, resolveThreadBindingMaxAgeExpiresAt as w, resolveBindingRecordKey as x, resetThreadBindingsForTests as y };
+export { toReusableWebhookKey as A, resolveThreadBindingMaxAgeExpiresAt as C, shouldDefaultPersist as D, setBindingRecord as E, shouldPersistBindingMutations as O, resolveThreadBindingInactivityExpiresAt as S, saveBindingsToDisk as T, rememberThreadBindingToken as _, THREAD_BINDINGS_MAX_ENTRIES as a, resolveBindingRecordKey as b, ensureBindingsLoaded as c, normalizePersistedBinding as d, normalizeTargetKind as f, rememberReusableWebhook as g, refreshUnboundThreadWebhookIdentity as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toBindingRecordKey as k, forgetThreadBindingToken as l, normalizeThreadId as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizeThreadBindingDurationMs as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as s, BINDINGS_BY_THREAD_ID as t, getThreadBindingToken as u, removeBindingRecord as v, resolveThreadBindingMaxAgeMs as w, resolveThreadBindingIdleTimeoutMs as x, resolveBindingIdsForSession as y };

package/dist/{transcripts-source-DIKGsTGT.js → transcripts-source-CfFMexGt.js}

@@ -1,4 +1,4 @@
-import { Yt as __exportAll } from "./chunk-DX4jpFQP.js";
+import { tn as __exportAll } from "./retry-CLpJcXXf.js";
 //#region extensions/discord/src/voice/transcripts-source.ts
 var transcripts_source_exports = /* @__PURE__ */ __exportAll({
 	discordVoiceTranscriptsSourceProvider: () => discordVoiceTranscriptsSourceProvider,

package/dist/transcripts-source-api.js

@@ -1,2 +1,2 @@
-import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-DIKGsTGT.js";
+import { t as discordVoiceTranscriptsSourceProvider } from "./transcripts-source-CfFMexGt.js";
 export { discordVoiceTranscriptsSourceProvider };

package/dist/{typing--Mzo2kM7.js → typing-CS-nNVoe.js}

@@ -1,4 +1,4 @@
-import { Dt as sendChannelTyping, Yt as __exportAll } from "./chunk-DX4jpFQP.js";
+import { Nt as sendChannelTyping, tn as __exportAll } from "./retry-CLpJcXXf.js";
 import { c as raceWithTimeout } from "./timeouts-B9cy6RvQ.js";
 //#region extensions/discord/src/monitor/typing.ts
 var typing_exports = /* @__PURE__ */ __exportAll({ sendTyping: () => sendTyping });