@gaodefa/daocore 2026.5.50 → 2026.5.51

package/dist/thread-bindings-CJDUpwXD.js

@@ -1,228 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
-import { n as normalizeAccountId } from "./account-id-B32J-iNN.js";
-import { d as resolveAgentIdFromSessionKey } from "./session-key-Bte0mmcq.js";
-import { i as registerSessionBindingAdapter, o as unregisterSessionBindingAdapter } from "./session-binding-service-Dt5NxtK1.js";
-import { c as resolveThreadBindingMaxAgeMsForChannel, o as resolveThreadBindingIdleTimeoutMsForChannel } from "./thread-bindings-policy-BZBsdp3j.js";
-import "./string-coerce-runtime-DcopKqDR.js";
-import "./routing-AC-P99jg.js";
-import "./conversation-runtime-CAGsRmgG.js";
-import { t as resolveThreadBindingConversationIdFromBindingId } from "./thread-binding-id-DKmKA6Dw.js";
-//#region extensions/feishu/src/thread-bindings.ts
-const FEISHU_THREAD_BINDINGS_STATE_KEY = Symbol.for("daocore.feishuThreadBindingsState");
-let state;
-function getState() {
-	if (!state) {
-		const globalStore = globalThis;
-		state = globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] ?? {
-			managersByAccountId: /* @__PURE__ */ new Map(),
-			bindingsByAccountConversation: /* @__PURE__ */ new Map()
-		};
-		globalStore[FEISHU_THREAD_BINDINGS_STATE_KEY] = state;
-	}
-	return state;
-}
-function resolveBindingKey(params) {
-	return `${params.accountId}:${params.conversationId}`;
-}
-function toSessionBindingTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "session";
-}
-function toFeishuTargetKind(raw) {
-	return raw === "subagent" ? "subagent" : "acp";
-}
-function toSessionBindingRecord(record, defaults) {
-	const idleExpiresAt = defaults.idleTimeoutMs > 0 ? record.lastActivityAt + defaults.idleTimeoutMs : void 0;
-	const maxAgeExpiresAt = defaults.maxAgeMs > 0 ? record.boundAt + defaults.maxAgeMs : void 0;
-	const expiresAt = idleExpiresAt != null && maxAgeExpiresAt != null ? Math.min(idleExpiresAt, maxAgeExpiresAt) : idleExpiresAt ?? maxAgeExpiresAt;
-	return {
-		bindingId: resolveBindingKey({
-			accountId: record.accountId,
-			conversationId: record.conversationId
-		}),
-		targetSessionKey: record.targetSessionKey,
-		targetKind: toSessionBindingTargetKind(record.targetKind),
-		conversation: {
-			channel: "feishu",
-			accountId: record.accountId,
-			conversationId: record.conversationId,
-			parentConversationId: record.parentConversationId
-		},
-		status: "active",
-		boundAt: record.boundAt,
-		expiresAt,
-		metadata: {
-			agentId: record.agentId,
-			label: record.label,
-			boundBy: record.boundBy,
-			deliveryTo: record.deliveryTo,
-			deliveryThreadId: record.deliveryThreadId,
-			lastActivityAt: record.lastActivityAt,
-			idleTimeoutMs: defaults.idleTimeoutMs,
-			maxAgeMs: defaults.maxAgeMs
-		}
-	};
-}
-function createFeishuThreadBindingManager(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const existing = getState().managersByAccountId.get(accountId);
-	if (existing) return existing;
-	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMsForChannel({
-		cfg: params.cfg,
-		channel: "feishu",
-		accountId
-	});
-	const maxAgeMs = resolveThreadBindingMaxAgeMsForChannel({
-		cfg: params.cfg,
-		channel: "feishu",
-		accountId
-	});
-	const manager = {
-		accountId,
-		getByConversationId: (conversationId) => getState().bindingsByAccountConversation.get(resolveBindingKey({
-			accountId,
-			conversationId
-		})),
-		listBySessionKey: (targetSessionKey) => [...getState().bindingsByAccountConversation.values()].filter((record) => record.accountId === accountId && record.targetSessionKey === targetSessionKey),
-		bindConversation: ({ conversationId, parentConversationId, targetKind, targetSessionKey, metadata }) => {
-			const normalizedConversationId = conversationId.trim();
-			const normalizedTargetSessionKey = targetSessionKey.trim();
-			if (!normalizedConversationId || !normalizedTargetSessionKey) return null;
-			const existing = getState().bindingsByAccountConversation.get(resolveBindingKey({
-				accountId,
-				conversationId: normalizedConversationId
-			}));
-			const now = Date.now();
-			const record = {
-				accountId,
-				conversationId: normalizedConversationId,
-				parentConversationId: normalizeOptionalString(parentConversationId) ?? existing?.parentConversationId,
-				deliveryTo: typeof metadata?.deliveryTo === "string" && metadata.deliveryTo.trim() ? metadata.deliveryTo.trim() : existing?.deliveryTo,
-				deliveryThreadId: typeof metadata?.deliveryThreadId === "string" && metadata.deliveryThreadId.trim() ? metadata.deliveryThreadId.trim() : existing?.deliveryThreadId,
-				targetKind: toFeishuTargetKind(targetKind),
-				targetSessionKey: normalizedTargetSessionKey,
-				agentId: typeof metadata?.agentId === "string" && metadata.agentId.trim() ? metadata.agentId.trim() : existing?.agentId ?? resolveAgentIdFromSessionKey(normalizedTargetSessionKey),
-				label: typeof metadata?.label === "string" && metadata.label.trim() ? metadata.label.trim() : existing?.label,
-				boundBy: typeof metadata?.boundBy === "string" && metadata.boundBy.trim() ? metadata.boundBy.trim() : existing?.boundBy,
-				boundAt: now,
-				lastActivityAt: now
-			};
-			getState().bindingsByAccountConversation.set(resolveBindingKey({
-				accountId,
-				conversationId: normalizedConversationId
-			}), record);
-			return record;
-		},
-		touchConversation: (conversationId, at = Date.now()) => {
-			const key = resolveBindingKey({
-				accountId,
-				conversationId
-			});
-			const existingRecord = getState().bindingsByAccountConversation.get(key);
-			if (!existingRecord) return null;
-			const updated = {
-				...existingRecord,
-				lastActivityAt: at
-			};
-			getState().bindingsByAccountConversation.set(key, updated);
-			return updated;
-		},
-		unbindConversation: (conversationId) => {
-			const key = resolveBindingKey({
-				accountId,
-				conversationId
-			});
-			const existingRecord = getState().bindingsByAccountConversation.get(key);
-			if (!existingRecord) return null;
-			getState().bindingsByAccountConversation.delete(key);
-			return existingRecord;
-		},
-		unbindBySessionKey: (targetSessionKey) => {
-			const removed = [];
-			for (const record of getState().bindingsByAccountConversation.values()) {
-				if (record.accountId !== accountId || record.targetSessionKey !== targetSessionKey) continue;
-				getState().bindingsByAccountConversation.delete(resolveBindingKey({
-					accountId,
-					conversationId: record.conversationId
-				}));
-				removed.push(record);
-			}
-			return removed;
-		},
-		stop: () => {
-			for (const key of getState().bindingsByAccountConversation.keys()) if (key.startsWith(`${accountId}:`)) getState().bindingsByAccountConversation.delete(key);
-			getState().managersByAccountId.delete(accountId);
-			unregisterSessionBindingAdapter({
-				channel: "feishu",
-				accountId,
-				adapter: sessionBindingAdapter
-			});
-		}
-	};
-	const sessionBindingAdapter = {
-		channel: "feishu",
-		accountId,
-		capabilities: { placements: ["current"] },
-		bind: async (input) => {
-			if (input.conversation.channel !== "feishu" || input.placement === "child") return null;
-			const bound = manager.bindConversation({
-				conversationId: input.conversation.conversationId,
-				parentConversationId: input.conversation.parentConversationId,
-				targetKind: input.targetKind,
-				targetSessionKey: input.targetSessionKey,
-				metadata: input.metadata
-			});
-			return bound ? toSessionBindingRecord(bound, {
-				idleTimeoutMs,
-				maxAgeMs
-			}) : null;
-		},
-		listBySession: (targetSessionKey) => manager.listBySessionKey(targetSessionKey).map((entry) => toSessionBindingRecord(entry, {
-			idleTimeoutMs,
-			maxAgeMs
-		})),
-		resolveByConversation: (ref) => {
-			if (ref.channel !== "feishu") return null;
-			const found = manager.getByConversationId(ref.conversationId);
-			return found ? toSessionBindingRecord(found, {
-				idleTimeoutMs,
-				maxAgeMs
-			}) : null;
-		},
-		touch: (bindingId, at) => {
-			const conversationId = resolveThreadBindingConversationIdFromBindingId({
-				accountId,
-				bindingId
-			});
-			if (conversationId) manager.touchConversation(conversationId, at);
-		},
-		unbind: async (input) => {
-			if (input.targetSessionKey?.trim()) return manager.unbindBySessionKey(input.targetSessionKey.trim()).map((entry) => toSessionBindingRecord(entry, {
-				idleTimeoutMs,
-				maxAgeMs
-			}));
-			const conversationId = resolveThreadBindingConversationIdFromBindingId({
-				accountId,
-				bindingId: input.bindingId
-			});
-			if (!conversationId) return [];
-			const removed = manager.unbindConversation(conversationId);
-			return removed ? [toSessionBindingRecord(removed, {
-				idleTimeoutMs,
-				maxAgeMs
-			})] : [];
-		}
-	};
-	registerSessionBindingAdapter(sessionBindingAdapter);
-	getState().managersByAccountId.set(accountId, manager);
-	return manager;
-}
-function getFeishuThreadBindingManager(accountId) {
-	return getState().managersByAccountId.get(normalizeAccountId(accountId)) ?? null;
-}
-const testing = { resetFeishuThreadBindingsForTests() {
-	for (const manager of getState().managersByAccountId.values()) manager.stop();
-	getState().managersByAccountId.clear();
-	getState().bindingsByAccountConversation.clear();
-} };
-//#endregion
-export { getFeishuThreadBindingManager as n, testing as r, createFeishuThreadBindingManager as t };

package/dist/thread-bindings-DxvjdbzW.js

@@ -1,232 +0,0 @@
-import { c as normalizeOptionalString, s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
-import { n as normalizeAccountId } from "./account-id-B32J-iNN.js";
-import { n as readAcpSessionEntry } from "./session-meta-D0EJkrLy.js";
-import { a as resolveThreadBindingIdleTimeoutMs, s as resolveThreadBindingMaxAgeMs } from "./thread-bindings-policy-BZBsdp3j.js";
-import "./string-coerce-runtime-DcopKqDR.js";
-import "./routing-AC-P99jg.js";
-import "./conversation-runtime-CAGsRmgG.js";
-import { i as resolveThreadBindingThreadName, r as resolveThreadBindingIntroText } from "./thread-bindings-messages-D73K8IGt.js";
-import "./acp-runtime-CsYu7oyf.js";
-import { t as parseDiscordTarget } from "./target-parsing-D1FhMbX6.js";
-import "./targets-BoRwMAy3.js";
-import { O as shouldPersistBindingMutations, T as saveBindingsToDisk, c as getThreadBindingToken, f as normalizeThreadId, g as removeBindingRecord, n as MANAGERS_BY_ACCOUNT_ID, p as rememberRecentUnboundWebhookEcho, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-BOeDs7d_.js";
-import { r as resolveBindingIdsForTargetSession } from "./thread-bindings.session-updates-DQDLDktu.js";
-import { s as resolveChannelIdForBinding } from "./thread-bindings.discord-api-CnRP-DSi.js";
-import { r as getThreadBindingManager } from "./thread-bindings.manager-2B6_nSpQ.js";
-//#region extensions/discord/src/monitor/thread-bindings.config.ts
-function resolveDiscordThreadBindingIdleTimeoutMs(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const root = params.cfg.channels?.discord?.threadBindings;
-	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-	return resolveThreadBindingIdleTimeoutMs({
-		channelIdleHoursRaw: account?.idleHours ?? root?.idleHours,
-		sessionIdleHoursRaw: params.cfg.session?.threadBindings?.idleHours
-	});
-}
-function resolveDiscordThreadBindingMaxAgeMs(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const root = params.cfg.channels?.discord?.threadBindings;
-	const account = params.cfg.channels?.discord?.accounts?.[accountId]?.threadBindings;
-	return resolveThreadBindingMaxAgeMs({
-		channelMaxAgeHoursRaw: account?.maxAgeHours ?? root?.maxAgeHours,
-		sessionMaxAgeHoursRaw: params.cfg.session?.threadBindings?.maxAgeHours
-	});
-}
-//#endregion
-//#region extensions/discord/src/monitor/thread-bindings.lifecycle.ts
-const ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT = 8;
-async function mapWithConcurrency(params) {
-	if (params.items.length === 0) return [];
-	const limit = Math.max(1, Math.floor(params.limit));
-	const resultsByIndex = /* @__PURE__ */ new Map();
-	let nextIndex = 0;
-	const runWorker = async () => {
-		for (;;) {
-			const index = nextIndex;
-			nextIndex += 1;
-			if (index >= params.items.length) return;
-			resultsByIndex.set(index, await params.worker(params.items[index], index));
-		}
-	};
-	const workers = Array.from({ length: Math.min(limit, params.items.length) }, () => runWorker());
-	await Promise.all(workers);
-	return params.items.map((_item, index) => resultsByIndex.get(index));
-}
-function listThreadBindingsForAccount(accountId) {
-	const manager = getThreadBindingManager(accountId);
-	if (!manager) return [];
-	return manager.listBindings();
-}
-function listThreadBindingsBySessionKey(params) {
-	return resolveBindingIdsForTargetSession(params).map((bindingKey) => BINDINGS_BY_THREAD_ID.get(bindingKey)).filter((entry) => Boolean(entry));
-}
-async function autoBindSpawnedDiscordSubagent(params) {
-	if (normalizeOptionalLowercaseString(params.channel) !== "discord") return null;
-	const manager = getThreadBindingManager(params.accountId);
-	if (!manager) return null;
-	const managerToken = getThreadBindingToken(manager.accountId);
-	const requesterThreadId = normalizeThreadId(params.threadId);
-	let channelId = "";
-	if (requesterThreadId) {
-		const existing = manager.getByThreadId(requesterThreadId);
-		if (existing?.channelId?.trim()) channelId = existing.channelId.trim();
-		else channelId = await resolveChannelIdForBinding({
-			cfg: params.cfg,
-			accountId: manager.accountId,
-			token: managerToken,
-			threadId: requesterThreadId
-		}) ?? "";
-	}
-	if (!channelId) {
-		const to = normalizeOptionalString(params.to) ?? "";
-		if (!to) return null;
-		try {
-			const target = parseDiscordTarget(to, { defaultKind: "channel" });
-			if (!target || target.kind !== "channel") return null;
-			channelId = await resolveChannelIdForBinding({
-				cfg: params.cfg,
-				accountId: manager.accountId,
-				token: managerToken,
-				threadId: target.id
-			}) ?? "";
-		} catch {
-			return null;
-		}
-	}
-	return await manager.bindTarget({
-		threadId: void 0,
-		channelId,
-		createThread: true,
-		threadName: resolveThreadBindingThreadName({
-			agentId: params.agentId,
-			label: params.label
-		}),
-		targetKind: "subagent",
-		targetSessionKey: params.childSessionKey,
-		agentId: params.agentId,
-		label: params.label,
-		boundBy: params.boundBy ?? "system",
-		introText: resolveThreadBindingIntroText({
-			agentId: params.agentId,
-			label: params.label,
-			idleTimeoutMs: manager.getIdleTimeoutMs(),
-			maxAgeMs: manager.getMaxAgeMs()
-		})
-	});
-}
-function unbindThreadBindingsBySessionKey(params) {
-	const ids = resolveBindingIdsForTargetSession(params);
-	if (ids.length === 0) return [];
-	const removed = [];
-	for (const bindingKey of ids) {
-		const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
-		if (!record) continue;
-		const manager = MANAGERS_BY_ACCOUNT_ID.get(record.accountId);
-		if (manager) {
-			const unbound = manager.unbindThread({
-				threadId: record.threadId,
-				reason: params.reason,
-				sendFarewell: params.sendFarewell,
-				farewellText: params.farewellText
-			});
-			if (unbound) removed.push(unbound);
-			continue;
-		}
-		const unbound = removeBindingRecord(bindingKey);
-		if (unbound) {
-			rememberRecentUnboundWebhookEcho(unbound);
-			removed.push(unbound);
-		}
-	}
-	if (removed.length > 0 && shouldPersistBindingMutations()) saveBindingsToDisk({ force: true });
-	return removed;
-}
-function resolveStoredAcpBindingHealth(params) {
-	if (!params.session.acp) return "stale";
-	return "healthy";
-}
-async function reconcileAcpThreadBindingsOnStartup(params) {
-	const manager = getThreadBindingManager(params.accountId);
-	if (!manager) return {
-		checked: 0,
-		removed: 0,
-		staleSessionKeys: []
-	};
-	const acpBindings = manager.listBindings().filter((binding) => binding.targetKind === "acp" && binding.metadata?.pluginBindingOwner !== "plugin");
-	const staleBindings = [];
-	const probeTargets = [];
-	for (const binding of acpBindings) {
-		const sessionKey = binding.targetSessionKey.trim();
-		if (!sessionKey) {
-			staleBindings.push(binding);
-			continue;
-		}
-		const session = readAcpSessionEntry({
-			cfg: params.cfg,
-			sessionKey
-		});
-		if (!session) {
-			staleBindings.push(binding);
-			continue;
-		}
-		if (session.storeReadFailed) continue;
-		if (resolveStoredAcpBindingHealth({ session }) === "stale") {
-			staleBindings.push(binding);
-			continue;
-		}
-		if (!params.healthProbe) continue;
-		probeTargets.push({
-			binding,
-			sessionKey,
-			session
-		});
-	}
-	if (params.healthProbe && probeTargets.length > 0) {
-		const probeResults = await mapWithConcurrency({
-			items: probeTargets,
-			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
-			worker: async ({ binding, sessionKey, session }) => {
-				try {
-					return {
-						binding,
-						status: (await params.healthProbe?.({
-							cfg: params.cfg,
-							accountId: manager.accountId,
-							sessionKey,
-							binding,
-							session
-						}))?.status ?? "uncertain"
-					};
-				} catch {
-					return {
-						binding,
-						status: "uncertain"
-					};
-				}
-			}
-		});
-		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
-	}
-	if (staleBindings.length === 0) return {
-		checked: acpBindings.length,
-		removed: 0,
-		staleSessionKeys: []
-	};
-	const staleSessionKeys = [];
-	let removed = 0;
-	for (const binding of staleBindings) {
-		staleSessionKeys.push(binding.targetSessionKey);
-		if (manager.unbindThread({
-			threadId: binding.threadId,
-			reason: "stale-session",
-			sendFarewell: params.sendFarewell ?? false
-		})) removed += 1;
-	}
-	return {
-		checked: acpBindings.length,
-		removed,
-		staleSessionKeys: [...new Set(staleSessionKeys)]
-	};
-}
-//#endregion
-export { unbindThreadBindingsBySessionKey as a, reconcileAcpThreadBindingsOnStartup as i, listThreadBindingsBySessionKey as n, resolveDiscordThreadBindingIdleTimeoutMs as o, listThreadBindingsForAccount as r, resolveDiscordThreadBindingMaxAgeMs as s, autoBindSpawnedDiscordSubagent as t };

package/dist/thread-bindings.discord-api-CnRP-DSi.js

@@ -1,187 +0,0 @@
-import { c as normalizeOptionalString } from "./string-coerce-DyL154ka.js";
-import { r as logVerbose } from "./globals-DhGeOA1P.js";
-import "./runtime-env-BSECk1Nm.js";
-import "./string-coerce-runtime-DcopKqDR.js";
-import { t as SYSTEM_MARK } from "./system-message-DcYqWFJX.js";
-import "./conversation-runtime-CAGsRmgG.js";
-import "./text-chunking-ObhJDe8L.js";
-import { n as resolveDiscordChannelId } from "./target-parsing-D1FhMbX6.js";
-import { It as ChannelType, at as getChannel, q as createChannelWebhook } from "./discord-DLn5dEWC.js";
-import { N as createDiscordRestClient } from "./send.shared-DkEjcqxQ.js";
-import { l as createThreadDiscord, s as sendWebhookMessageDiscord } from "./send-BZbyJL0A.js";
-import { t as sendMessageDiscord } from "./send.outbound-C2EaQ1Hx.js";
-import { i as REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL, k as toReusableWebhookKey, m as rememberReusableWebhook, t as BINDINGS_BY_THREAD_ID } from "./thread-bindings.state-BOeDs7d_.js";
-import { n as resolveDiscordChannelInfoSafe, t as resolveDiscordChannelIdSafe } from "./channel-access-C12aDZ0p.js";
-//#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 `${SYSTEM_MARK} ${normalizePersonaLabel(params.label) || normalizePersonaLabel(params.agentId) || "agent"}`.slice(0, THREAD_BINDING_PERSONA_MAX_CHARS);
-}
-function resolveThreadBindingPersonaFromRecord(record) {
-	return resolveThreadBindingPersona({
-		label: record.label,
-		agentId: record.agentId
-	});
-}
-//#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) {
-	if (typeof value === "number" && Number.isFinite(value)) return Math.trunc(value);
-	if (typeof value === "string" && /^\d+$/.test(value.trim())) return Number(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: "DaoCore 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,
-			autoArchiveMinutes: 60
-		}, {
-			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
-export { isThreadArchived as a, summarizeDiscordError as c, isDiscordThreadGoneError as i, resolveThreadBindingPersona as l, createWebhookForChannel as n, maybeSendBindingMessage as o, findReusableWebhook as r, resolveChannelIdForBinding as s, createThreadForBinding as t, resolveThreadBindingPersonaFromRecord as u };