@openclaw/discord 2026.9.1 → 2026.9.3

package/dist/thread-bindings.manager-DM7M3vzn.js

@@ -0,0 +1,673 @@
+import { Ht as __exportAll, et as createChannelWebhook, ft as getChannel } from "./discord-CmL3ati-.js";
+import { t as canFallbackDiscordWebhookSend, y as resolveDiscordChannelId } from "./retry-B0lQ1Ado.js";
+import { P as createDiscordRestClient } from "./send.shared-D4BAjlRo.js";
+import { t as sendMessageDiscord } from "./send.outbound-DF0P3C9J.js";
+import { t as isDiscordThreadChannelType } from "./channel-type-CVLZyGYS.js";
+import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.js";
+import { c as sendWebhookMessageDiscord, u as createThreadDiscord } from "./send-Bdp3zZH5.js";
+import { C as saveBindingsToDisk, O as toReusableWebhookKey, S as resolveThreadBindingMaxAgeMs$1, T as shouldDefaultPersist, _ as resolveBindingRecordKey, a as THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS, c as getThreadBindingToken, d as normalizeThreadId, f as refreshUnboundThreadWebhookIdentity, g as resolveBindingIdsForSession, h as removeBindingRecord, i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, l as normalizeTargetKind, m as rememberThreadBindingToken, n as MANAGERS_BY_ACCOUNT_ID, o as ensureBindingsLoaded, p as rememberReusableWebhook, r as PERSIST_BY_ACCOUNT_ID, s as forgetThreadBindingToken, t as BINDINGS_BY_THREAD_ID, u as normalizeThreadBindingDurationMs, v as resolvePreparedThreadBindingLifecycle, w as setBindingRecord, y as resolveThreadBindingIdleTimeoutMs$1 } from "./thread-bindings.state-jNRrsgzV.js";
+import { parseStrictNonNegativeInteger } from "openclaw/plugin-sdk/number-runtime";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { getRuntimeConfigSnapshot } from "openclaw/plugin-sdk/runtime-config-snapshot";
+import { createSubsystemLogger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
+import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
+import { SYSTEM_MARK } from "openclaw/plugin-sdk/text-chunking";
+import { formatThreadBindingDurationLabel, registerSessionBindingAdapter, resolveThreadBindingConversationIdFromBindingId, resolveThreadBindingFarewellText, resolveThreadBindingIntroText, resolveThreadBindingThreadName, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/conversation-runtime";
+import { resolveSessionAgentIdStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
+//#region extensions/discord/src/monitor/thread-bindings.persona.ts
+const THREAD_BINDING_PERSONA_MAX_CHARS = 80;
+function normalizePersonaLabel(value) {
+	if (!value) return;
+	return value.replace(/\s+/g, " ").trim() || void 0;
+}
+function resolveThreadBindingPersona(params) {
+	const base = normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent";
+	return truncateUtf16Safe(`${SYSTEM_MARK} ${base}`, THREAD_BINDING_PERSONA_MAX_CHARS);
+}
+function resolveThreadBindingPersonaFromRecord(record) {
+	return resolveThreadBindingPersona({
+		label: record.label,
+		agentId: record.agentId
+	});
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.types.ts
+const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 12e4;
+const DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS = 864e5;
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.discord-api.ts
+const log = createSubsystemLogger("discord/thread-bindings");
+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 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(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) {
+		const fallbackToBot = canFallbackDiscordWebhookSend(err);
+		log.warn("discord thread binding webhook send failed", {
+			error: summarizeDiscordError(err),
+			fallbackToBot
+		});
+		if (!fallbackToBot) return;
+	}
+	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 && isDiscordThreadChannelType(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 {
+		const created = await createThreadDiscord(params.channelId, { name: params.threadName }, {
+			cfg: params.cfg,
+			accountId: params.accountId,
+			token: params.token
+		});
+		return (normalizeOptionalString(created?.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) ?? "";
+	if (!trimmed) return;
+	try {
+		return resolveDiscordChannelId(trimmed);
+	} catch {
+		return;
+	}
+}
+function toSessionBindingTargetKind(raw) {
+	return raw === "subagent" ? "subagent" : "session";
+}
+function toThreadBindingTargetKind(raw) {
+	return raw === "subagent" ? "subagent" : "acp";
+}
+function toSessionBindingRecord(record, defaults) {
+	const bindingId = resolveBindingRecordKey({
+		accountId: record.accountId,
+		threadId: record.threadId
+	}) ?? `${record.accountId}:${record.threadId}`;
+	const lifecycle = resolvePreparedThreadBindingLifecycle({
+		record,
+		...defaults
+	});
+	return {
+		bindingId,
+		targetSessionKey: record.targetSessionKey,
+		targetKind: toSessionBindingTargetKind(record.targetKind),
+		conversation: {
+			channel: "discord",
+			accountId: record.accountId,
+			conversationId: record.threadId,
+			parentConversationId: record.channelId
+		},
+		status: "active",
+		boundAt: record.boundAt,
+		expiresAt: lifecycle.expiresAt,
+		metadata: {
+			agentId: record.agentId,
+			label: record.label,
+			webhookId: record.webhookId,
+			webhookToken: record.webhookToken,
+			boundBy: record.boundBy,
+			lastActivityAt: record.lastActivityAt,
+			idleTimeoutMs: lifecycle.idleTimeoutMs,
+			maxAgeMs: lifecycle.maxAgeMs,
+			...record.metadata
+		}
+	};
+}
+function createThreadBindingSessionAdapter(params) {
+	const serializeBinding = (entry) => toSessionBindingRecord(entry, params.defaults);
+	return {
+		channel: "discord",
+		accountId: params.accountId,
+		capabilities: { placements: ["current", "child"] },
+		bind: async (input) => {
+			if (input.conversation.channel !== "discord") return null;
+			const targetSessionKey = input.targetSessionKey.trim();
+			if (!targetSessionKey) return null;
+			const conversationId = normalizeOptionalString(input.conversation.conversationId) ?? "";
+			const placement = input.placement === "child" ? "child" : "current";
+			const metadata = input.metadata ?? {};
+			const label = normalizeOptionalString(metadata.label);
+			const threadName = typeof metadata.threadName === "string" ? normalizeOptionalString(metadata.threadName) : void 0;
+			const introText = typeof metadata.introText === "string" ? normalizeOptionalString(metadata.introText) : void 0;
+			const boundBy = typeof metadata.boundBy === "string" ? normalizeOptionalString(metadata.boundBy) : void 0;
+			const agentId = typeof metadata.agentId === "string" ? normalizeOptionalString(metadata.agentId) : void 0;
+			let threadId;
+			let channelId;
+			let createThread = false;
+			if (placement === "child") {
+				createThread = true;
+				channelId = normalizeChildBindingParentChannelId(input.conversation.parentConversationId);
+				if (!channelId && conversationId) channelId = await resolveChannelIdForBinding({
+					cfg: params.resolveCurrentCfg(),
+					accountId: params.accountId,
+					token: params.resolveCurrentToken(),
+					threadId: conversationId
+				}) ?? void 0;
+			} else threadId = conversationId || void 0;
+			const bound = await params.manager.bindTarget({
+				threadId,
+				channelId,
+				createThread,
+				threadName,
+				targetKind: toThreadBindingTargetKind(input.targetKind),
+				targetSessionKey,
+				agentId,
+				label,
+				boundBy,
+				introText,
+				metadata
+			});
+			return bound ? serializeBinding(bound) : null;
+		},
+		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 ? serializeBinding(binding) : null;
+		},
+		touch: (bindingId, at) => {
+			const threadId = resolveThreadBindingConversationIdFromBindingId({
+				accountId: params.accountId,
+				bindingId
+			});
+			if (!threadId) return;
+			params.manager.touchThread({
+				threadId,
+				at,
+				persist: true
+			});
+		},
+		unbind: async (input) => {
+			if (input.targetSessionKey?.trim()) return params.manager.unbindBySessionKey({
+				targetSessionKey: input.targetSessionKey,
+				reason: input.reason
+			}).map(serializeBinding);
+			const threadId = resolveThreadBindingConversationIdFromBindingId({
+				accountId: params.accountId,
+				bindingId: input.bindingId
+			});
+			if (!threadId) return [];
+			const removed = params.manager.unbindThread({
+				threadId,
+				reason: input.reason
+			});
+			return removed ? [serializeBinding(removed)] : [];
+		}
+	};
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.manager.ts
+var thread_bindings_manager_exports = /* @__PURE__ */ __exportAll({
+	createNoopThreadBindingManager: () => createNoopThreadBindingManager,
+	createThreadBindingManager: () => createThreadBindingManager,
+	getThreadBindingManager: () => getThreadBindingManager
+});
+function createNoopManager(accountIdRaw) {
+	return {
+		accountId: normalizeAccountId(accountIdRaw),
+		getIdleTimeoutMs: () => DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS,
+		getMaxAgeMs: () => 0,
+		getByThreadId: () => void 0,
+		getBySessionKey: () => void 0,
+		listBySessionKey: () => [],
+		listBindings: () => [],
+		touchThread: () => null,
+		bindTarget: async () => null,
+		unbindThread: () => null,
+		unbindBySessionKey: () => [],
+		stop: () => {}
+	};
+}
+function isDirectConversationBindingId(value) {
+	const trimmed = normalizeOptionalString(value);
+	return Boolean(trimmed && /^(user:|channel:)/i.test(trimmed));
+}
+function createThreadBindingManager(params) {
+	ensureBindingsLoaded();
+	const accountId = normalizeAccountId(params.accountId);
+	const existing = MANAGERS_BY_ACCOUNT_ID.get(accountId);
+	if (existing) {
+		rememberThreadBindingToken({
+			accountId,
+			token: params.token
+		});
+		return existing;
+	}
+	rememberThreadBindingToken({
+		accountId,
+		token: params.token
+	});
+	const persist = params.persist ?? shouldDefaultPersist();
+	PERSIST_BY_ACCOUNT_ID.set(accountId, persist);
+	const idleTimeoutMs = normalizeThreadBindingDurationMs(params.idleTimeoutMs, DEFAULT_THREAD_BINDING_IDLE_TIMEOUT_MS);
+	const maxAgeMs = normalizeThreadBindingDurationMs(params.maxAgeMs, 0);
+	const resolveCurrentCfg = () => getRuntimeConfigSnapshot() ?? params.cfg;
+	const resolveCurrentToken = () => getThreadBindingToken(accountId) ?? params.token;
+	const getCurrentBinding = (threadId) => MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager ? manager.getByThreadId(threadId) : void 0;
+	let sweepTimer = null;
+	const runSweepOnce = async () => {
+		const bindings = manager.listBindings();
+		if (bindings.length === 0) return;
+		let rest = null;
+		for (const snapshotBinding of bindings) {
+			const binding = getCurrentBinding(snapshotBinding.threadId);
+			if (!binding) continue;
+			const now = Date.now();
+			const lifecycle = resolvePreparedThreadBindingLifecycle({
+				record: binding,
+				idleTimeoutMs,
+				maxAgeMs
+			});
+			const { expiresAt, reason } = lifecycle;
+			if (expiresAt != null && reason && now >= expiresAt) {
+				manager.unbindThread({
+					threadId: binding.threadId,
+					reason,
+					sendFarewell: true,
+					farewellText: resolveThreadBindingFarewellText({
+						reason,
+						idleTimeoutMs: lifecycle.idleTimeoutMs,
+						maxAgeMs: lifecycle.maxAgeMs
+					})
+				});
+				continue;
+			}
+			if (isDirectConversationBindingId(binding.threadId)) continue;
+			if (!rest) try {
+				const cfg = resolveCurrentCfg();
+				rest = createDiscordRestClient({
+					cfg,
+					accountId,
+					token: resolveCurrentToken()
+				}).rest;
+			} catch {
+				return;
+			}
+			try {
+				const channel = await getChannel(rest, binding.threadId);
+				if (getCurrentBinding(binding.threadId) !== binding) continue;
+				if (!channel || typeof channel !== "object") {
+					logVerbose(`discord thread binding sweep probe returned invalid payload for ${binding.threadId}`);
+					continue;
+				}
+				if (isThreadArchived(channel)) manager.unbindThread({
+					threadId: binding.threadId,
+					reason: "thread-archived",
+					sendFarewell: true
+				});
+			} catch (err) {
+				if (getCurrentBinding(binding.threadId) !== binding) continue;
+				if (isDiscordThreadGoneError(err)) {
+					logVerbose(`discord thread binding sweep removing stale binding ${binding.threadId}: ${summarizeDiscordError(err)}`);
+					manager.unbindThread({
+						threadId: binding.threadId,
+						reason: "thread-delete",
+						sendFarewell: false
+					});
+					continue;
+				}
+				logVerbose(`discord thread binding sweep probe failed for ${binding.threadId}: ${summarizeDiscordError(err)}`);
+			}
+		}
+	};
+	const manager = {
+		accountId,
+		getIdleTimeoutMs: () => idleTimeoutMs,
+		getMaxAgeMs: () => maxAgeMs,
+		getByThreadId: (threadId) => {
+			const key = resolveBindingRecordKey({
+				accountId,
+				threadId
+			});
+			if (!key) return;
+			const entry = BINDINGS_BY_THREAD_ID.get(key);
+			if (!entry || entry.accountId !== accountId) return;
+			return entry;
+		},
+		getBySessionKey: (targetSessionKey) => {
+			return manager.listBySessionKey(targetSessionKey)[0];
+		},
+		listBySessionKey: (targetSessionKey) => {
+			return resolveBindingIdsForSession({
+				targetSessionKey,
+				accountId
+			}).map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey)).filter((entry) => Boolean(entry));
+		},
+		listBindings: () => [...BINDINGS_BY_THREAD_ID.values()].filter((entry) => entry.accountId === accountId),
+		touchThread: (touchParams) => {
+			const key = resolveBindingRecordKey({
+				accountId,
+				threadId: touchParams.threadId
+			});
+			if (!key) return null;
+			const existingResult = BINDINGS_BY_THREAD_ID.get(key);
+			if (!existingResult || existingResult.accountId !== accountId) return null;
+			const now = Date.now();
+			const at = typeof touchParams.at === "number" && Number.isFinite(touchParams.at) ? Math.max(0, Math.floor(touchParams.at)) : now;
+			const nextRecord = {
+				...existingResult,
+				lastActivityAt: Math.max(existingResult.lastActivityAt || 0, at)
+			};
+			setBindingRecord(nextRecord);
+			if (touchParams.persist ?? persist) saveBindingsToDisk({ minIntervalMs: THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS });
+			return nextRecord;
+		},
+		bindTarget: async (bindParams) => {
+			const cfg = resolveCurrentCfg();
+			let threadId = normalizeThreadId(bindParams.threadId);
+			let channelId = normalizeOptionalString(bindParams.channelId) ?? "";
+			const directConversationBinding = isDirectConversationBindingId(threadId) || isDirectConversationBindingId(channelId);
+			if (!threadId && bindParams.createThread) {
+				if (!channelId) return null;
+				const threadName = resolveThreadBindingThreadName({
+					agentId: bindParams.agentId,
+					label: bindParams.label
+				});
+				threadId = await createThreadForBinding({
+					cfg,
+					accountId,
+					token: resolveCurrentToken(),
+					channelId,
+					threadName: normalizeOptionalString(bindParams.threadName) ?? threadName
+				}) ?? void 0;
+			}
+			if (!threadId) return null;
+			if (!channelId && directConversationBinding) channelId = threadId;
+			if (!channelId) channelId = await resolveChannelIdForBinding({
+				cfg,
+				accountId,
+				token: resolveCurrentToken(),
+				threadId,
+				channelId: bindParams.channelId
+			}) ?? "";
+			if (!channelId) return null;
+			const existingValue = manager.getByThreadId(threadId);
+			const targetSessionKey = normalizeOptionalString(bindParams.targetSessionKey) ?? "";
+			if (!targetSessionKey) return null;
+			const targetKind = normalizeTargetKind(bindParams.targetKind, targetSessionKey);
+			const previous = existingValue?.targetSessionKey === targetSessionKey && existingValue.targetKind === targetKind ? existingValue : void 0;
+			let webhookId = normalizeOptionalString(bindParams.webhookId) ?? normalizeOptionalString(existingValue?.webhookId) ?? "";
+			let webhookToken = normalizeOptionalString(bindParams.webhookToken) ?? normalizeOptionalString(existingValue?.webhookToken) ?? "";
+			if (!directConversationBinding && (!webhookId || !webhookToken)) {
+				const cachedWebhook = findReusableWebhook({
+					accountId,
+					channelId
+				});
+				webhookId = cachedWebhook.webhookId ?? "";
+				webhookToken = cachedWebhook.webhookToken ?? "";
+			}
+			if (!directConversationBinding && (!webhookId || !webhookToken)) {
+				const createdWebhook = await createWebhookForChannel({
+					cfg,
+					accountId,
+					token: resolveCurrentToken(),
+					channelId
+				});
+				webhookId = createdWebhook.webhookId ?? "";
+				webhookToken = createdWebhook.webhookToken ?? "";
+			}
+			const now = Date.now();
+			const record = {
+				accountId,
+				channelId,
+				threadId,
+				targetKind,
+				targetSessionKey,
+				agentId: normalizeOptionalString(bindParams.agentId) ?? normalizeOptionalString(previous?.agentId) ?? resolveSessionAgentIdStrict({
+					config: cfg,
+					sessionKey: targetSessionKey
+				}),
+				label: normalizeOptionalString(bindParams.label) ?? normalizeOptionalString(previous?.label),
+				webhookId: webhookId || void 0,
+				webhookToken: webhookToken || void 0,
+				boundBy: normalizeOptionalString(bindParams.boundBy) ?? normalizeOptionalString(previous?.boundBy) ?? "system",
+				boundAt: now,
+				lastActivityAt: now,
+				idleTimeoutMs: typeof existingValue?.idleTimeoutMs === "number" ? existingValue.idleTimeoutMs : idleTimeoutMs,
+				maxAgeMs: typeof existingValue?.maxAgeMs === "number" ? existingValue.maxAgeMs : maxAgeMs,
+				metadata: {
+					...previous?.metadata,
+					...bindParams.metadata
+				}
+			};
+			setBindingRecord(record);
+			if (persist) saveBindingsToDisk();
+			const introText = bindParams.introText?.trim();
+			if (introText && cfg) maybeSendBindingMessage({
+				cfg,
+				record,
+				text: introText
+			});
+			return record;
+		},
+		unbindThread: (unbindParams) => {
+			const bindingKey = resolveBindingRecordKey({
+				accountId,
+				threadId: unbindParams.threadId
+			});
+			if (!bindingKey) return null;
+			const existingLocal = BINDINGS_BY_THREAD_ID.get(bindingKey);
+			if (!existingLocal || existingLocal.accountId !== accountId) return null;
+			const removed = removeBindingRecord(bindingKey);
+			if (!removed) return null;
+			refreshUnboundThreadWebhookIdentity(removed);
+			if (persist) saveBindingsToDisk();
+			if (unbindParams.sendFarewell !== false) {
+				const cfg = resolveCurrentCfg();
+				const farewell = resolveThreadBindingFarewellText({
+					reason: unbindParams.reason,
+					farewellText: unbindParams.farewellText,
+					idleTimeoutMs: resolveThreadBindingIdleTimeoutMs$1({
+						record: removed,
+						defaultIdleTimeoutMs: idleTimeoutMs
+					}),
+					maxAgeMs: resolveThreadBindingMaxAgeMs$1({
+						record: removed,
+						defaultMaxAgeMs: maxAgeMs
+					})
+				});
+				if (cfg) maybeSendBindingMessage({
+					cfg,
+					record: removed,
+					text: farewell,
+					preferWebhook: false
+				});
+			}
+			return removed;
+		},
+		unbindBySessionKey: (unbindParams) => {
+			const ids = resolveBindingIdsForSession({
+				targetSessionKey: unbindParams.targetSessionKey,
+				accountId,
+				targetKind: unbindParams.targetKind
+			});
+			if (ids.length === 0) return [];
+			const removed = [];
+			for (const bindingKey of ids) {
+				const binding = BINDINGS_BY_THREAD_ID.get(bindingKey);
+				if (!binding) continue;
+				const entry = manager.unbindThread({
+					threadId: binding.threadId,
+					reason: unbindParams.reason,
+					sendFarewell: unbindParams.sendFarewell,
+					farewellText: unbindParams.farewellText
+				});
+				if (entry) removed.push(entry);
+			}
+			return removed;
+		},
+		stop: () => {
+			if (sweepTimer) {
+				clearInterval(sweepTimer);
+				sweepTimer = null;
+			}
+			if (MANAGERS_BY_ACCOUNT_ID.get(accountId) === manager) {
+				MANAGERS_BY_ACCOUNT_ID.delete(accountId);
+				forgetThreadBindingToken(accountId);
+			}
+			unregisterSessionBindingAdapter({
+				channel: "discord",
+				accountId,
+				adapter: sessionBindingAdapter
+			});
+		}
+	};
+	if (params.enableSweeper !== false) {
+		sweepTimer = setInterval(() => {
+			runSweepOnce();
+		}, THREAD_BINDINGS_SWEEP_INTERVAL_MS);
+		if (!(process.env.VITEST || false)) sweepTimer.unref?.();
+	}
+	const sessionBindingAdapter = createThreadBindingSessionAdapter({
+		accountId,
+		manager,
+		defaults: {
+			idleTimeoutMs,
+			maxAgeMs
+		},
+		resolveCurrentCfg,
+		resolveCurrentToken
+	});
+	registerSessionBindingAdapter(sessionBindingAdapter);
+	MANAGERS_BY_ACCOUNT_ID.set(accountId, manager);
+	return manager;
+}
+function createNoopThreadBindingManager(accountId) {
+	return createNoopManager(accountId);
+}
+function getThreadBindingManager(accountId) {
+	const normalized = normalizeAccountId(accountId);
+	return MANAGERS_BY_ACCOUNT_ID.get(normalized) ?? null;
+}
+//#endregion
+export { isThreadArchived as a, resolveThreadBindingPersonaFromRecord as c, resolveThreadBindingThreadName as d, thread_bindings_manager_exports as i, formatThreadBindingDurationLabel as l, createThreadBindingManager as n, resolveChannelIdForBinding as o, getThreadBindingManager as r, resolveThreadBindingPersona as s, createNoopThreadBindingManager as t, resolveThreadBindingIntroText as u };