@openclaw/discord 2026.9.4 → 2026.9.6

package/dist/{retry-DKeoT7UO.js → .setup/retry-BEYkDy0P.mjs}

@@ -1,4 +1,4 @@
-import { v as RateLimitError } from "./discord-CmL3ati-.js";
+import { v as RateLimitError } from "./discord-BXpHW-cu.mjs";
 import { parseStrictNonNegativeInteger, resolveIntegerOption } from "openclaw/plugin-sdk/number-runtime";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
@@ -7,7 +7,7 @@ import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKi
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 import { chunkByParagraph } from "openclaw/plugin-sdk/reply-chunking";
-import { avoidTrailingHighSurrogateBreak, chunkTextForOutbound, findCodeRegions } from "openclaw/plugin-sdk/text-chunking";
+import { chunkTextForOutbound, findCodeRegions } from "openclaw/plugin-sdk/text-chunking";
 import { isSingleUseReplyToMode } from "openclaw/plugin-sdk/reply-reference";
 import { createMessageReceiptFromOutboundResults } from "openclaw/plugin-sdk/channel-outbound";
 import { attachChannelToResults } from "openclaw/plugin-sdk/channel-send-result";
@@ -65,6 +65,11 @@ function resolveDiscordChannelId(raw) {
 function normalizeDiscordMessagingTarget(raw) {
 	return parseDiscordTarget(raw, { defaultKind: "channel" })?.normalized;
 }
+function matchesDiscordToolContextTarget(params) {
+	const target = normalizeDiscordMessagingTarget(params.target);
+	if (!target) return false;
+	return [params.toolContext.currentChannelId, params.toolContext.currentMessagingTarget].some((currentTarget) => currentTarget !== void 0 && normalizeDiscordMessagingTarget(currentTarget) === target);
+}
 /**
 * Normalize a Discord outbound target for delivery. Bare numeric IDs are
 * prefixed with "channel:" to avoid the ambiguous-target error in
@@ -217,6 +222,42 @@ function createDiscordSendResult(params) {
 	};
 }
 //#endregion
+//#region packages/normalization-core/src/utf16-slice.ts
+function isHighSurrogate(codeUnit) {
+	return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+	return codeUnit >= 56320 && codeUnit <= 57343;
+}
+/** Moves a chunk boundary away from the middle of a UTF-16 surrogate pair. */
+function avoidTrailingHighSurrogateBreak(text, start, end) {
+	if (end <= start || end >= text.length || !isHighSurrogate(text.charCodeAt(end - 1)) || !isLowSurrogate(text.charCodeAt(end))) return end;
+	const adjusted = end - 1;
+	return adjusted > start ? adjusted : end + 1;
+}
+//#endregion
+//#region packages/normalization-core/src/grapheme.ts
+let graphemeSegmenter;
+function getGraphemeSegmenter() {
+	graphemeSegmenter ??= new Intl.Segmenter(void 0, { granularity: "grapheme" });
+	return graphemeSegmenter;
+}
+/**
+* Chooses a whole-grapheme cut within the hard budget, honoring a usable preference.
+* If no whole grapheme fits, allowPartial permits a surrogate-safe progress cut;
+* a leading surrogate pair can exceed maxEnd by one code unit.
+*/
+function findGraphemeChunkEnd(text, start, maxEnd, preferredEnd = maxEnd, allowPartial = true) {
+	const hardEnd = Math.min(maxEnd, text.length);
+	if (hardEnd <= start) return start;
+	const preferred = Number.isInteger(preferredEnd) && preferredEnd > start && preferredEnd <= hardEnd ? preferredEnd : hardEnd;
+	if (preferred === text.length) return preferred;
+	const segments = getGraphemeSegmenter().segment(text);
+	let end = segments.containing(preferred)?.index ?? preferred;
+	if (end <= start && preferred < hardEnd) end = hardEnd === text.length ? hardEnd : segments.containing(hardEnd)?.index ?? hardEnd;
+	return end > start ? end : allowPartial ? avoidTrailingHighSurrogateBreak(text, start, hardEnd) : start;
+}
+//#endregion
 //#region extensions/discord/src/chunk.ts
 const DEFAULT_MAX_CHARS = 2e3;
 const DEFAULT_MAX_LINES = 17;
@@ -320,12 +361,15 @@ function chunkDiscordText(text, opts = {}) {
 				start,
 				end
 			};
-			const exceeds = openFence && !ranges.fenceAt(end) ? !fits(candidate) : raw(candidate).length > charLimit || countLines(raw(candidate)) > lineLimit || ranges.overlaps(start, end) && !fits(candidate);
+			const closesBlock = openFence && !ranges.fenceAt(end);
+			let candidateText = raw(candidate);
+			const exceeds = closesBlock ? !fits(candidate) : candidateText.length > charLimit || countLines(candidateText) > lineLimit || ranges.overlaps(start, end) && !fits(candidate);
 			if (current && exceeds) {
 				current = flush(current);
 				candidate.start = current?.start ?? (ranges.joins(consumed, segmentStart) ? consumed : segmentStart);
+				candidateText = raw(candidate);
 			}
-			current = raw(candidate) ? candidate : void 0;
+			current = candidateText ? candidate : void 0;
 			segmentStart = end;
 		}
 		lineStart += line.length + 1;
@@ -445,24 +489,53 @@ function createDiscordRanges(source, maxChars, maxLines) {
 		offset += line.length + 1;
 	}
 	if (!fence) collect(source.length);
-	const overlaps = (start, end) => spans.some((span) => span.start < end && span.end > start);
-	const joins = (end, start) => end <= start && spans.some((span) => span.start < end && end < span.end && start < span.end);
+	const firstSpanEndingAfter = (position) => {
+		let low = 0;
+		let high = spans.length;
+		while (low < high) {
+			const middle = low + Math.floor((high - low) / 2);
+			if (expectDefined(spans[middle], "Discord inline span").end <= position) low = middle + 1;
+			else high = middle;
+		}
+		return low;
+	};
+	const firstPrefixEndingAfter = (position) => {
+		let low = 0;
+		let high = spans.length;
+		while (low < high) {
+			const middle = low + Math.floor((high - low) / 2);
+			const span = expectDefined(spans[middle], "Discord inline span");
+			if (span.base + span.code.prefix.end <= position) low = middle + 1;
+			else high = middle;
+		}
+		return spans[low];
+	};
+	const overlaps = (start, end) => {
+		const span = spans[firstSpanEndingAfter(start)];
+		return Boolean(span && span.start < end);
+	};
+	const joins = (end, start) => {
+		if (end > start) return false;
+		const span = spans[firstSpanEndingAfter(end)];
+		return Boolean(span && span.start < end && start < span.end);
+	};
 	const boundary = (start, end) => {
-		let safe = avoidTrailingHighSurrogateBreak(source, start, end);
-		for (const span of spans) {
-			const prefix = span.code.prefix;
-			if (span.base + prefix.start < safe && safe < span.base + prefix.end) return span.base + prefix.start;
-			if (span.start < safe && safe < span.end) {
-				if (source[safe - 1] === "\r" && source[safe] === "\n") safe -= 1;
-				if (span.atomicTicks) while (source[safe - 1] === "`" && source[safe] === "`") safe -= 1;
-			}
+		let safe = findGraphemeChunkEnd(source, start, end);
+		if (safe === end - 1 && source[end - 1] === "\r" && source[end] === "\n") safe = end;
+		const prefixSpan = firstPrefixEndingAfter(safe);
+		if (prefixSpan && prefixSpan.base + prefixSpan.code.prefix.start < safe) return prefixSpan.base + prefixSpan.code.prefix.start;
+		const span = spans[firstSpanEndingAfter(safe)];
+		if (span && span.start < safe) {
+			if (source[safe - 1] === "\r" && source[safe] === "\n") safe -= 1;
+			if (span.atomicTicks) while (source[safe - 1] === "`" && source[safe] === "`") safe -= 1;
 		}
 		return safe;
 	};
 	const render = (start, end) => {
 		let cursor = start, text = "";
-		for (const span of spans) {
-			if (span.end <= start || span.start >= end) continue;
+		for (let index = firstSpanEndingAfter(start); index < spans.length; index += 1) {
+			const span = expectDefined(spans[index], "Discord inline span");
+			if (span.start >= end) break;
 			const prefix = span.code.prefix;
 			const prefixStart = span.base + prefix.start;
 			if (start > span.base + prefix.ownerStart && cursor <= prefixStart) {
@@ -483,10 +556,24 @@ function createDiscordRanges(source, maxChars, maxLines) {
 		}
 		return text + source.slice(cursor, end);
 	};
-	const fenceAt = (position) => fences.find((range) => range.bodyStart - 1 <= position && (position < range.end || position === range.end && range.closeStart === range.end));
+	const fenceEndingAtOrAfter = (position) => {
+		let low = 0;
+		let high = fences.length;
+		while (low < high) {
+			const middle = low + Math.floor((high - low) / 2);
+			if (expectDefined(fences[middle], "Discord fence range").end < position) low = middle + 1;
+			else high = middle;
+		}
+		return fences[low];
+	};
+	const fenceAt = (position) => {
+		const range = fenceEndingAtOrAfter(position);
+		return range && range.bodyStart - 1 <= position && (position < range.end || position === range.end && range.closeStart === range.end) ? range : void 0;
+	};
 	const cutBoundary = (start, end) => {
 		const safe = boundary(start, end);
-		for (const range of fences) {
+		const range = fenceEndingAtOrAfter(safe);
+		if (range) {
 			if (start < range.start && range.start < safe && safe <= range.bodyStart) return range.start;
 			if (range.closeStart < safe && safe < range.end) return range.closeStart;
 		}
@@ -605,4 +692,4 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-export { normalizeDiscordOutboundTarget as _, recordDiscordMessageCreateAmbiguity as a, createDiscordSendReceiptFromResults as c, createReusableDiscordReplyReference as d, resolveDiscordReplyMessageId as f, normalizeDiscordMessagingTarget as g, looksLikeDiscordTargetId as h, hasDiscordMessageCreateAmbiguity as i, createDiscordSendResult as l, allowFromContainsDiscordUserId as m, classifyDiscordDeliveryFailure as n, chunkDiscordTextWithMode as o, resolveDiscordReplyReference as p, createDiscordRetryRunner as r, createDiscordSendReceipt as s, canFallbackDiscordWebhookSend as t, toDiscordOutboundDeliveryResult as u, parseDiscordTarget as v, resolveDiscordChannelId as y };
+export { normalizeDiscordMessagingTarget as _, recordDiscordMessageCreateAmbiguity as a, resolveDiscordChannelId as b, createDiscordSendReceiptFromResults as c, createReusableDiscordReplyReference as d, resolveDiscordReplyMessageId as f, matchesDiscordToolContextTarget as g, looksLikeDiscordTargetId as h, hasDiscordMessageCreateAmbiguity as i, createDiscordSendResult as l, allowFromContainsDiscordUserId as m, classifyDiscordDeliveryFailure as n, chunkDiscordTextWithMode as o, resolveDiscordReplyReference as p, createDiscordRetryRunner as r, createDiscordSendReceipt as s, canFallbackDiscordWebhookSend as t, toDiscordOutboundDeliveryResult as u, normalizeDiscordOutboundTarget as v, parseDiscordTarget as y };