@openclaw/discord 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{send.receipt-DVOg2Oaw.mjs → send.receipt-BAlzXd8e.mjs}

@@ -1,4 +1,5 @@
-import { v as RateLimitError } from "./discord-9gysrhzp.mjs";
+import { R as RateLimitError } from "./discord-BGqgx-yd.mjs";
+import { t as parseDiscordTarget } from "./target-parsing-C-HyNxcE.mjs";
 import { collectErrorGraphCandidates, extractErrorCode, formatErrorMessage, readErrorName } from "openclaw/plugin-sdk/error-runtime";
 import { sleepWithAbort } from "openclaw/plugin-sdk/runtime-env";
 import { expectDefined } from "openclaw/plugin-sdk/expect-runtime";
@@ -6,8 +7,6 @@ import { parseStrictNonNegativeInteger, resolveIntegerOption } from "openclaw/pl
 import { chunkByParagraph } from "openclaw/plugin-sdk/reply-chunking";
 import { chunkTextForOutbound, findCodeRegions } from "openclaw/plugin-sdk/text-chunking";
 import { classifyTransientNetworkErrorCode, createChannelApiRetryRunner, resolveRetryConfig, retryAsync } from "openclaw/plugin-sdk/retry-runtime";
-import { buildMessagingTarget, parseMentionPrefixOrAtUserTarget, requireTargetKind } from "openclaw/plugin-sdk/channel-targets";
-import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
 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";
@@ -47,6 +46,9 @@ function findGraphemeChunkEnd(text, start, maxEnd, preferredEnd = maxEnd, allowP
 	if (hardEnd <= start) return start;
 	const preferred = Number.isInteger(preferredEnd) && preferredEnd > start && preferredEnd <= hardEnd ? preferredEnd : hardEnd;
 	if (preferred === text.length) return preferred;
+	const before = text.charCodeAt(preferred - 1);
+	const after = text.charCodeAt(preferred);
+	if (Number.isInteger(preferred) && before <= 127 && after <= 127 && !(before === 13 && after === 10)) return preferred;
 	const segments = getGraphemeSegmenter().segment(text);
 	let end = containingSegment(segments, text, preferred)?.index ?? preferred;
 	if (end <= start && preferred < hardEnd) end = hardEnd === text.length ? hardEnd : containingSegment(segments, text, hardEnd)?.index ?? hardEnd;
@@ -62,9 +64,6 @@ const FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
 function hasReasoningItalics(text) {
 	return /^(?:Reasoning:|Thinking\.{0,3})\n+_/u.test(text) && text.trimEnd().endsWith("_");
 }
-function resolveDiscordChunkLimit(value, fallback) {
-	return resolveIntegerOption(value, fallback, { min: 1 });
-}
 function countLines(text) {
 	if (!text) return 0;
 	let count = 1;
@@ -88,8 +87,8 @@ function closesFence(open, close) {
 	return open.marker[0] === close.marker[0] && close.marker.length >= open.marker.length;
 }
 function chunkDiscordText(text, opts = {}) {
-	const hardMaxChars = resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS);
-	const maxLines = resolveDiscordChunkLimit(opts.maxLines, DEFAULT_MAX_LINES);
+	const hardMaxChars = resolveIntegerOption(opts.maxChars, DEFAULT_MAX_CHARS, { min: 1 });
+	const maxLines = resolveIntegerOption(opts.maxLines, DEFAULT_MAX_LINES, { min: 1 });
 	if (!text) return [];
 	if (text.length <= hardMaxChars && countLines(text) <= maxLines) return [text];
 	const maxChars = hardMaxChars >= MIN_REASONING_ITALICS_CHUNK_CHARS && hasReasoningItalics(text) ? hardMaxChars - REASONING_ITALICS_MARKER_CHARS : hardMaxChars;
@@ -98,16 +97,14 @@ function chunkDiscordText(text, opts = {}) {
 	let current;
 	let consumed = 0;
 	let lineStart = 0;
-	const raw = (frame) => {
+	const raw = (frame, body = text.slice(frame.start, frame.end)) => {
 		const prefix = ranges.fenceAt(frame.start)?.reopenLine ?? "";
-		const body = text.slice(frame.start, frame.end);
 		return prefix + (prefix ? "\n" : "") + body;
 	};
 	const render = (frame) => {
 		const body = ranges.render(frame.start, frame.end);
 		if (body === void 0) return;
-		const prefix = ranges.fenceAt(frame.start)?.reopenLine ?? "";
-		const result = prefix + (prefix ? "\n" : "") + body;
+		const result = raw(frame, body);
 		const close = ranges.fenceAt(frame.end);
 		return close?.reopenLine ? result + (result.endsWith("\n") ? "" : "\n") + close.closeLine : result;
 	};
@@ -174,7 +171,7 @@ function chunkDiscordText(text, opts = {}) {
 }
 function chunkDiscordTextWithMode(text, opts) {
 	if ((opts.chunkMode ?? "length") !== "newline") return chunkDiscordText(text, opts);
-	return chunkByParagraph(text, resolveDiscordChunkLimit(opts.maxChars, DEFAULT_MAX_CHARS), { splitLongParagraphs: false }).flatMap((line) => {
+	return chunkByParagraph(text, resolveIntegerOption(opts.maxChars, DEFAULT_MAX_CHARS, { min: 1 }), { splitLongParagraphs: false }).flatMap((line) => {
 		const chunks = chunkDiscordText(line, opts);
 		return chunks.length || !line ? chunks : [line];
 	});
@@ -379,13 +376,16 @@ const DISCORD_RETRY_DEFAULTS = {
 const DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS = 2;
 const DISCORD_TRANSIENT_MESSAGE_RE = /\b(?:bad gateway|fetch failed|network error|networkerror|service unavailable|socket hang up|temporarily unavailable|timed out|timeout)\b|connection (?:closed|reset|refused)/i;
 const ambiguousDiscordMessageCreates = /* @__PURE__ */ new WeakSet();
+function collectDiscordErrorCandidates(error) {
+	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]);
+}
 function readDiscordErrorStatus(err) {
 	if (!err || typeof err !== "object") return;
 	const raw = "status" in err && err.status !== void 0 ? err.status : "statusCode" in err && err.statusCode !== void 0 ? err.statusCode : void 0;
 	return parseStrictNonNegativeInteger(raw);
 }
 function classifyDiscordDeliveryFailure(error) {
-	const candidates = collectErrorGraphCandidates(error, (current) => [current.cause, current.error]);
+	const candidates = collectDiscordErrorCandidates(error);
 	for (const candidate of candidates) {
 		const status = readDiscordErrorStatus(candidate);
 		if (status !== void 0) {
@@ -401,7 +401,7 @@ function recordDiscordMessageCreateAmbiguity(error) {
 	if (error !== null && typeof error === "object") ambiguousDiscordMessageCreates.add(error);
 }
 function hasDiscordMessageCreateAmbiguity(error) {
-	return collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => candidate !== null && typeof candidate === "object" && ambiguousDiscordMessageCreates.has(candidate));
+	return collectDiscordErrorCandidates(error).some((candidate) => candidate !== null && typeof candidate === "object" && ambiguousDiscordMessageCreates.has(candidate));
 }
 function canFallbackDiscordWebhookSend(error) {
 	if (hasDiscordMessageCreateAmbiguity(error)) return false;
@@ -409,28 +409,17 @@ function canFallbackDiscordWebhookSend(error) {
 	return failure === "rejected" || failure === "pre-connect";
 }
 function hasDiscordRateLimitRejection(error) {
-	return error instanceof RateLimitError || collectErrorGraphCandidates(error, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) === 429);
+	return error instanceof RateLimitError || collectDiscordErrorCandidates(error).some((candidate) => readDiscordErrorStatus(candidate) === 429);
 }
-function isRetryableDiscordTransientError(error) {
+function isRetryableDiscordError(error, safety = "idempotent") {
 	const failure = classifyDiscordDeliveryFailure(error);
-	return failure === "ambiguous" || failure === "pre-connect" || hasDiscordRateLimitRejection(error);
-}
-function isRetryableDiscordPreConnectError(error) {
-	const failure = classifyDiscordDeliveryFailure(error);
-	return failure === "pre-connect" || failure === "rejected" && hasDiscordRateLimitRejection(error);
-}
-function resolveDiscordRetryPredicate(safety) {
-	return safety === "non-idempotent-create" ? isRetryableDiscordPreConnectError : isRetryableDiscordTransientError;
-}
-function isRetryableDiscordGatewayTransportError(err) {
-	if (!isRetryableDiscordTransientError(err) || err instanceof RateLimitError) return false;
-	return !collectErrorGraphCandidates(err, (current) => [current.cause, current.error]).some((candidate) => readDiscordErrorStatus(candidate) !== void 0);
+	return failure === "pre-connect" || (safety === "non-idempotent-create" ? failure === "rejected" && hasDiscordRateLimitRejection(error) : failure === "ambiguous" || hasDiscordRateLimitRejection(error));
 }
 function createDiscordRetryRunner(params) {
 	const retryConfig = resolveRetryConfig(DISCORD_RETRY_DEFAULTS, params.retry);
 	const attempts = retryConfig.attempts > 1 ? retryConfig.attempts + DISCORD_GATEWAY_RECONNECT_EXTRA_ATTEMPTS : retryConfig.attempts;
 	return (fn, label, options) => {
-		const isRetryable = resolveDiscordRetryPredicate(options?.safety ?? "idempotent");
+		const safety = options?.safety ?? "idempotent";
 		let observedGatewayDisconnect = false;
 		const runRequest = async () => {
 			if (params.signal?.aborted) throw params.signal.reason instanceof Error ? params.signal.reason : /* @__PURE__ */ new Error("Discord request aborted");
@@ -442,7 +431,7 @@ function createDiscordRetryRunner(params) {
 				throw err;
 			}
 		};
-		const shouldRetry = (err, attempt) => isRetryable(err) && (attempt < retryConfig.attempts || observedGatewayDisconnect && isRetryableDiscordGatewayTransportError(err));
+		const shouldRetry = (err, attempt) => isRetryableDiscordError(err, safety) && (attempt < retryConfig.attempts || observedGatewayDisconnect && isRetryableDiscordError(err) && !(err instanceof RateLimitError) && !collectDiscordErrorCandidates(err).some((candidate) => readDiscordErrorStatus(candidate) !== void 0));
 		const retryAfterMs = (err) => err instanceof RateLimitError ? err.retryAfter * 1e3 : void 0;
 		const signal = params.signal;
 		if (signal) return retryAsync(runRequest, {
@@ -472,56 +461,6 @@ function createDiscordRetryRunner(params) {
 	};
 }
 //#endregion
-//#region extensions/discord/src/target-parsing.ts
-function parseDiscordTarget(raw, options = {}) {
-	const trimmed = raw.trim();
-	if (!trimmed) return;
-	const providerPrefixedTarget = parseDiscordProviderPrefixedTarget(trimmed);
-	if (providerPrefixedTarget) return providerPrefixedTarget;
-	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 parseDiscordProviderPrefixedTarget(raw) {
-	const match = /^discord:(channel|user):(.+)$/i.exec(raw);
-	if (!match) return;
-	const kind = match[1]?.toLowerCase();
-	const id = match[2]?.trim();
-	if (!kind || !id) return;
-	return buildMessagingTarget(kind, id, `${kind}:${id}`);
-}
-function resolveDiscordChannelId(raw) {
-	const target = parseDiscordTarget(raw, { defaultKind: "channel" });
-	return requireTargetKind({
-		platform: "Discord",
-		target,
-		kind: "channel"
-	});
-}
-//#endregion
 //#region extensions/discord/src/normalize.ts
 function normalizeDiscordMessagingTarget(raw) {
 	return parseDiscordTarget(raw, { defaultKind: "channel" })?.normalized;
@@ -543,16 +482,10 @@ function normalizeDiscordOutboundTarget(to, allowFrom) {
 		ok: false,
 		error: /* @__PURE__ */ new Error("Discord recipient is required. Use \"channel:<id>\" for channels or \"user:<id>\" for DMs.")
 	};
-	if (/^\d+$/.test(trimmed)) {
-		if (allowFromContainsDiscordUserId(allowFrom, trimmed)) return {
-			ok: true,
-			to: `user:${trimmed}`
-		};
-		return {
-			ok: true,
-			to: `channel:${trimmed}`
-		};
-	}
+	if (/^\d+$/.test(trimmed)) return {
+		ok: true,
+		to: `${allowFromContainsDiscordUserId(allowFrom, trimmed) ? "user" : "channel"}:${trimmed}`
+	};
 	return {
 		ok: true,
 		to: trimmed
@@ -561,18 +494,10 @@ function normalizeDiscordOutboundTarget(to, allowFrom) {
 function allowFromContainsDiscordUserId(allowFrom, userId) {
 	const normalizedUserId = userId.trim();
 	if (!normalizedUserId) return false;
-	const normalizedAllowFrom = (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).filter((entry) => Boolean(entry));
-	return resolveAllowlistMatchByCandidates({
-		allowList: normalizedAllowFrom,
-		candidates: [{
-			value: normalizedUserId,
-			source: "id"
-		}]
-	}).allowed;
+	return (allowFrom ?? []).map(normalizeAllowFromDiscordUserId).includes(normalizedUserId);
 }
 function normalizeAllowFromDiscordUserId(entry) {
 	const trimmed = entry.trim().toLowerCase();
-	if (!trimmed || trimmed === "*") return;
 	const mentionMatch = /^<@!?(\d+)>$/.exec(trimmed);
 	if (mentionMatch) return mentionMatch[1];
 	return /^(?:(?:discord:)?user:|discord:)?(\d+)$/.exec(trimmed)?.[1];
@@ -654,18 +579,17 @@ function createDiscordSendReceipt(params) {
 function createDiscordSendResult(params) {
 	const messageId = params.result.id ?? "";
 	const channelId = params.result.channel_id ?? params.fallbackChannelId;
-	const receiptParams = {
-		platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
-		channelId,
-		kind: params.kind
-	};
-	if (params.threadId != null) receiptParams.threadId = String(params.threadId);
-	if (params.reply) receiptParams.reply = params.reply;
 	return {
 		messageId,
 		channelId,
-		receipt: createDiscordSendReceipt(receiptParams)
+		receipt: createDiscordSendReceipt({
+			platformMessageIds: params.result.platformMessageIds?.length ? params.result.platformMessageIds : [messageId],
+			channelId,
+			kind: params.kind,
+			threadId: params.threadId == null ? void 0 : String(params.threadId),
+			reply: params.reply
+		})
 	};
 }
 //#endregion
-export { createDiscordRetryRunner as _, createReusableDiscordReplyReference as a, chunkDiscordTextWithMode as b, allowFromContainsDiscordUserId as c, normalizeDiscordMessagingTarget as d, normalizeDiscordOutboundTarget as f, classifyDiscordDeliveryFailure as g, canFallbackDiscordWebhookSend as h, toDiscordOutboundDeliveryResult as i, looksLikeDiscordTargetId as l, resolveDiscordChannelId as m, createDiscordSendReceiptFromResults as n, resolveDiscordReplyMessageId as o, parseDiscordTarget as p, createDiscordSendResult as r, resolveDiscordReplyReference as s, createDiscordSendReceipt as t, matchesDiscordToolContextTarget as u, hasDiscordMessageCreateAmbiguity as v, findGraphemeChunkEnd as x, recordDiscordMessageCreateAmbiguity as y };
+export { recordDiscordMessageCreateAmbiguity as _, createReusableDiscordReplyReference as a, allowFromContainsDiscordUserId as c, normalizeDiscordMessagingTarget as d, normalizeDiscordOutboundTarget as f, hasDiscordMessageCreateAmbiguity as g, createDiscordRetryRunner as h, toDiscordOutboundDeliveryResult as i, looksLikeDiscordTargetId as l, classifyDiscordDeliveryFailure as m, createDiscordSendReceiptFromResults as n, resolveDiscordReplyMessageId as o, canFallbackDiscordWebhookSend as p, createDiscordSendResult as r, resolveDiscordReplyReference as s, createDiscordSendReceipt as t, matchesDiscordToolContextTarget as u, chunkDiscordTextWithMode as v, findGraphemeChunkEnd as y };