@openclaw/discord 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/target-parsing-C-HyNxcE.mjs

@@ -0,0 +1,48 @@
+import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
+//#region extensions/discord/src/target-parsing.ts
+function parseDiscordTarget(raw, options = {}) {
+	const trimmed = raw.trim();
+	if (!trimmed) return;
+	const providerPrefix = /^discord:(channel|user):(.+)$/i.exec(trimmed);
+	if (providerPrefix) {
+		const kind = providerPrefix[1]?.toLowerCase();
+		const id = providerPrefix[2]?.trim();
+		if (kind && id) return buildMessagingTarget(kind, id, `${kind}:${id}`);
+	}
+	const userTarget = parseMentionPrefixOrAtUserTarget({
+		raw: trimmed,
+		mentionPattern: /^<@!?(\d+)>$/,
+		prefixes: [
+			{
+				prefix: "user:",
+				kind: "user"
+			},
+			{
+				prefix: "channel:",
+				kind: "channel"
+			},
+			{
+				prefix: "discord:",
+				kind: "user"
+			}
+		],
+		atUserPattern: /^\d+$/,
+		atUserErrorMessage: "Discord DMs require a user id (use user:<id> or a <@id> mention)"
+	});
+	if (userTarget) return userTarget;
+	if (/^\d+$/.test(trimmed)) {
+		if (options.defaultKind) return buildMessagingTarget(options.defaultKind, trimmed, trimmed);
+		throw new Error(options.ambiguousMessage ?? `Ambiguous Discord recipient "${trimmed}". For DMs use "user:${trimmed}" or "<@${trimmed}>"; for channels use "channel:${trimmed}".`);
+	}
+	return buildMessagingTarget("channel", trimmed, trimmed);
+}
+function resolveDiscordChannelId(raw) {
+	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
+	return requireTargetKind({
+		platform: "Discord",
+		target,
+		kind: "channel"
+	});
+}
+//#endregion
+export { resolveDiscordChannelId as n, parseDiscordTarget as t };

package/dist/.setup/{target-resolver-CSFoPQ12.mjs → target-resolver-Bse8fuTi.mjs}

@@ -1,7 +1,8 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { c as resolveDiscordAccount, l as resolveDiscordAccountAllowFrom } from "./accounts-HE9-mj1L.mjs";
-import { c as allowFromContainsDiscordUserId, p as parseDiscordTarget } from "./send.receipt-DVOg2Oaw.mjs";
-import { o as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-Bipr0eUJ.mjs";
+import { l as resolveDiscordAccount, u as resolveDiscordAccountAllowFrom } from "./accounts-ljrzXBJi.mjs";
+import { c as allowFromContainsDiscordUserId } from "./send.receipt-BAlzXd8e.mjs";
+import { o as rememberDiscordDirectoryUser, r as listDiscordDirectoryPeersLive } from "./directory-live-DLygQVtW.mjs";
+import { t as parseDiscordTarget } from "./target-parsing-C-HyNxcE.mjs";
 import { buildMessagingTarget } from "openclaw/plugin-sdk/channel-targets";
 //#region extensions/discord/src/target-resolver.ts
 var target_resolver_exports = /* @__PURE__ */ __exportAll({
@@ -16,9 +17,12 @@ async function resolveDiscordTarget(raw, options, parseOptions = {}) {
 	const trimmed = raw.trim();
 	if (!trimmed) return;
 	const likelyUsername = !/^(user:|channel:|discord:|@|<@!?)|[\d]+$/.test(trimmed);
-	const shouldLookup = isExplicitUserLookup(trimmed, parseOptions) || likelyUsername;
-	if (/^\d+$/.test(trimmed) && parseOptions.defaultKind !== "user" && isConfiguredAllowedDiscordDmUser(trimmed, options)) return buildMessagingTarget("user", trimmed, trimmed);
-	const directParse = safeParseDiscordTarget(trimmed, parseOptions);
+	const shouldLookup = /^<@!?(\d+)>$/.test(trimmed) || /^(user:|discord:)/.test(trimmed) || trimmed.startsWith("@") || /^\d+$/.test(trimmed) && parseOptions.defaultKind === "user" || likelyUsername;
+	if (/^\d+$/.test(trimmed) && parseOptions.defaultKind !== "user" && allowFromContainsDiscordUserId(resolveDiscordAccountAllowFrom(options) ?? [], trimmed)) return buildMessagingTarget("user", trimmed, trimmed);
+	let directParse;
+	try {
+		directParse = parseDiscordTarget(trimmed, parseOptions);
+	} catch {}
 	if (directParse && directParse.kind !== "channel" && !likelyUsername) return directParse;
 	if (!shouldLookup) return directParse ?? parseDiscordTarget(trimmed, parseOptions);
 	try {
@@ -29,10 +33,7 @@ async function resolveDiscordTarget(raw, options, parseOptions = {}) {
 		}))[0];
 		if (match && match.kind === "user") {
 			const userId = match.id.replace(/^user:/, "");
-			const resolvedAccountId = resolveDiscordAccount({
-				cfg: options.cfg,
-				accountId: options.accountId
-			}).accountId;
+			const resolvedAccountId = resolveDiscordAccount(options).accountId;
 			rememberDiscordDirectoryUser({
 				accountId: resolvedAccountId,
 				userId,
@@ -52,22 +53,5 @@ async function parseAndResolveDiscordTarget(raw, options, parseOptions = {}) {
 	if (!resolved) throw new Error("Recipient is required for Discord sends");
 	return resolved;
 }
-function safeParseDiscordTarget(input, options) {
-	try {
-		return parseDiscordTarget(input, options);
-	} catch {
-		return;
-	}
-}
-function isConfiguredAllowedDiscordDmUser(input, options) {
-	const allowFrom = resolveDiscordAccountAllowFrom({
-		cfg: options.cfg,
-		accountId: options.accountId
-	}) ?? [];
-	return allowFromContainsDiscordUserId(allowFrom, input);
-}
-function isExplicitUserLookup(input, options) {
-	return /^<@!?(\d+)>$/.test(input) || /^(user:|discord:)/.test(input) || input.startsWith("@") || /^\d+$/.test(input) && options.defaultKind === "user";
-}
 //#endregion
 export { resolveDiscordTarget as n, target_resolver_exports as r, parseAndResolveDiscordTarget as t };

package/dist/.setup/targets-DZJjkzwv.mjs

@@ -0,0 +1,3 @@
+import "./target-parsing-C-HyNxcE.mjs";
+import "./target-resolver-Bse8fuTi.mjs";
+export {};

package/dist/.setup/{thread-bindings-DjQCkmsd.mjs → thread-bindings-0hPTSK14.mjs}

@@ -1,12 +1,12 @@
 import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
-import { p as parseDiscordTarget } from "./send.receipt-DVOg2Oaw.mjs";
-import "./targets-bqXQENmX.mjs";
-import { C as getThreadBindingToken, E as refreshUnboundThreadWebhookIdentity, F as resolveThreadBindingMaxAgeMs$1, M as resolveThreadBindingIdleTimeoutMs$1, N as resolveThreadBindingInactivityExpiresAt, P as resolveThreadBindingMaxAgeExpiresAt, _ as MANAGERS_BY_ACCOUNT_ID, a as mutateBindingsForTargetSession, g as BINDINGS_BY_THREAD_ID, i as setThreadBindingMaxAgeBySessionKeyAsync, n as setThreadBindingIdleTimeoutBySessionKeyAsync, o as resolveBindingIdsForTargetSession, r as setThreadBindingMaxAgeBySessionKey, t as setThreadBindingIdleTimeoutBySessionKey, u as removeBindingRecordSync } from "./thread-bindings.session-updates-Bu_CGr_O.mjs";
-import { c as resolveThreadBindingPersonaFromRecord, i as createNoopThreadBindingManager, n as getThreadBindingManager, o as resolveChannelIdForBinding, s as resolveThreadBindingPersona, t as createThreadBindingManager } from "./thread-bindings.manager-D2-GYZ5s.mjs";
-import { normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as parseDiscordTarget } from "./target-parsing-C-HyNxcE.mjs";
+import "./targets-DZJjkzwv.mjs";
+import { C as getThreadBindingToken, E as refreshUnboundThreadWebhookIdentity, F as resolveThreadBindingMaxAgeMs$1, M as resolveThreadBindingIdleTimeoutMs$1, N as resolveThreadBindingInactivityExpiresAt, P as resolveThreadBindingMaxAgeExpiresAt, _ as MANAGERS_BY_ACCOUNT_ID, a as mutateBindingsForTargetSession, g as BINDINGS_BY_THREAD_ID, i as setThreadBindingMaxAgeBySessionKeyAsync, n as setThreadBindingIdleTimeoutBySessionKeyAsync, o as resolveBindingIdsForTargetSession, r as setThreadBindingMaxAgeBySessionKey, t as setThreadBindingIdleTimeoutBySessionKey, u as removeBindingRecordSync } from "./thread-bindings.session-updates-DGSljVf6.mjs";
+import { c as resolveThreadBindingPersonaFromRecord, i as createNoopThreadBindingManager, n as getThreadBindingManager, o as resolveChannelIdForBinding, s as resolveThreadBindingPersona, t as createThreadBindingManager } from "./thread-bindings.manager-CdNa6UIs.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { normalizeOptionalLowercaseString, normalizeOptionalString, normalizeOptionalStringifiedId, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatThreadBindingDurationLabel as formatThreadBindingDurationLabel$1, resolveThreadBindingIdleTimeoutMs, resolveThreadBindingIntroText, resolveThreadBindingIntroText as resolveThreadBindingIntroText$1, resolveThreadBindingMaxAgeMs, resolveThreadBindingThreadName, resolveThreadBindingThreadName as resolveThreadBindingThreadName$1, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
-import { readAcpSessionEntry } from "openclaw/plugin-sdk/acp-runtime";
+import { prepareAcpSessionEntryRead, readAcpSessionEntry, rethrowIncognitoSessionError } from "openclaw/plugin-sdk/acp-runtime";
 import { runTasksWithConcurrency } from "openclaw/plugin-sdk/concurrency-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.config.ts
 function resolveDiscordThreadBindingIdleTimeoutMs(params) {
@@ -41,17 +41,18 @@ async function autoBindSpawnedDiscordSubagent(params) {
 	const manager = getThreadBindingManager(params.accountId);
 	if (!manager) return null;
 	const managerToken = getThreadBindingToken(manager.accountId);
+	const resolveChannel = (threadId) => resolveChannelIdForBinding({
+		cfg: params.cfg,
+		accountId: manager.accountId,
+		token: managerToken,
+		threadId
+	});
 	const requesterThreadId = normalizeOptionalStringifiedId(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
-		}) ?? "";
+		else channelId = await resolveChannel(requesterThreadId) ?? "";
 	}
 	if (!channelId) {
 		const to = normalizeOptionalString(params.to) ?? "";
@@ -59,12 +60,7 @@ async function autoBindSpawnedDiscordSubagent(params) {
 		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
-			}) ?? "";
+			channelId = await resolveChannel(target.id) ?? "";
 		} catch {
 			return null;
 		}
@@ -93,7 +89,6 @@ async function autoBindSpawnedDiscordSubagent(params) {
 /** @deprecated Public SDK compatibility; bundled callers use the awaited variant. */
 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);
@@ -117,6 +112,14 @@ async function unbindThreadBindingsBySessionKeyAsync(input) {
 	});
 }
 async function reconcileAcpThreadBindingsOnStartup(params) {
+	const preparations = /* @__PURE__ */ new Map();
+	try {
+		return await reconcileAcpThreadBindings(params, preparations);
+	} finally {
+		preparations.forEach((prepared) => prepared.release());
+	}
+}
+async function reconcileAcpThreadBindings(params, preparations) {
 	const manager = getThreadBindingManager(params.accountId);
 	if (!manager) return {
 		checked: 0,
@@ -132,17 +135,20 @@ async function reconcileAcpThreadBindingsOnStartup(params) {
 			staleBindings.push(binding);
 			continue;
 		}
-		const session = readAcpSessionEntry({
+		const input = {
 			cfg: params.cfg,
 			sessionKey,
 			agentId: binding.agentId
-		});
-		if (!session) {
-			staleBindings.push(binding);
-			continue;
+		};
+		const preparation = (params.prepareSession ?? prepareAcpSessionEntryRead)(input);
+		const prepared = preparation ? await preparation : void 0;
+		if (prepared) {
+			preparations.set(binding, prepared);
+			prepared.assertCurrent();
 		}
-		if (session.storeReadFailed) continue;
-		if (!session.acp) {
+		const session = prepared ? prepared.session : readAcpSessionEntry(input);
+		if (session?.storeReadFailed) continue;
+		if (!session?.acp) {
 			staleBindings.push(binding);
 			continue;
 		}
@@ -157,45 +163,48 @@ async function reconcileAcpThreadBindingsOnStartup(params) {
 		const { results: probeResults } = await runTasksWithConcurrency({
 			tasks: probeTargets.map(({ binding, sessionKey, session }) => async () => {
 				try {
-					return {
-						binding,
-						status: (await params.healthProbe?.({
-							cfg: params.cfg,
-							accountId: manager.accountId,
-							sessionKey,
-							binding,
-							session
-						}))?.status ?? "uncertain"
-					};
-				} catch {
-					return {
+					return (await params.healthProbe?.({
+						cfg: params.cfg,
+						accountId: manager.accountId,
+						sessionKey,
 						binding,
-						status: "uncertain"
-					};
+						session
+					}))?.status === "stale" ? binding : void 0;
+				} catch (error) {
+					rethrowIncognitoSessionError(error);
+					return;
 				}
 			}),
 			limit: ACP_STARTUP_HEALTH_PROBE_CONCURRENCY_LIMIT,
 			errorMode: "stop",
 			throwOnError: true
 		});
-		for (const probeResult of probeResults) if (probeResult.status === "stale") staleBindings.push(probeResult.binding);
+		for (const binding of probeResults) if (binding) staleBindings.push(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 (getThreadBindingManager(manager.accountId) !== manager || manager.getByThreadId(binding.threadId) !== binding) continue;
-		if (await manager.unbindThread({
-			threadId: binding.threadId,
-			expected: binding,
-			reason: "stale-session",
-			sendFarewell: params.sendFarewell ?? false
-		})) removed += 1;
+		let sourceFailure;
+		try {
+			if (await manager.unbindThread({
+				threadId: binding.threadId,
+				expected: binding,
+				assertCurrent() {
+					try {
+						preparations.get(binding)?.assertCurrent();
+					} catch (error) {
+						sourceFailure = error;
+						throw error;
+					}
+				},
+				reason: "stale-session",
+				sendFarewell: params.sendFarewell ?? false
+			})) removed += 1;
+		} finally {
+			rethrowIncognitoSessionError(sourceFailure);
+		}
 	}
 	return {
 		checked: acpBindings.length,