@openclaw/discord 2026.5.28 → 2026.5.30-beta.1

package/dist/{message-handler-BnhAHqem.js → message-handler-Deidymb-.js}

@@ -1,14 +1,15 @@
-import { I as createDiscordRestClient } from "./send.shared-Ddl21-Gt.js";
-import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-5QgEd_dW.js";
-import { a as mergeAbortSignals } from "./timeouts-l_PsHQvX.js";
-import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-CmB03FoF.js";
-import { t as sendTyping } from "./typing-B7bCMPJJ.js";
+import { I as createDiscordRestClient } from "./send.shared-DQwyGjXe.js";
+import { d as resolveDiscordChannelNameSafe, l as resolveDiscordChannelIdSafe, p as resolveDiscordChannelParentSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-CItgvv24.js";
+import { a as mergeAbortSignals } from "./timeouts-CEJ3--Uw.js";
+import { c as hasDiscordMessageStickers, d as resolveDiscordMessageChannelId, r as resolveDiscordMessageText } from "./message-utils-C4OlktSy.js";
+import { t as sendTyping } from "./typing-Bfns8H17.js";
 import { danger, logVerbose } from "openclaw/plugin-sdk/runtime-env";
-import { createChannelRunQueue } from "openclaw/plugin-sdk/channel-outbound";
+import { createChannelRunQueue, createTypingCallbacks, resolveChannelMessageSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-outbound";
 import { resolveOpenProviderRuntimeGroupPolicy } from "openclaw/plugin-sdk/runtime-group-policy";
 import { resolveBatchedReplyThreadingPolicy } from "openclaw/plugin-sdk/reply-reference";
 import { createChannelInboundDebouncer, shouldDebounceTextInbound } from "openclaw/plugin-sdk/channel-inbound";
 import { createClaimableDedupe } from "openclaw/plugin-sdk/persistent-dedupe";
+import { logTypingFailure } from "openclaw/plugin-sdk/channel-feedback";
 //#region extensions/discord/src/monitor/inbound-dedupe.ts
 const RECENT_DISCORD_MESSAGE_TTL_MS = 5 * 6e4;
 const RECENT_DISCORD_MESSAGE_MAX = 5e3;
@@ -59,7 +60,7 @@ function resolveDiscordInboundJobQueueKey(ctx) {
 	return ctx.messageChannelId;
 }
 function buildDiscordInboundJob(ctx, options) {
-	const { runtime, abortSignal, guildHistories, client, threadBindings, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
+	const { runtime, abortSignal, guildHistories, client, threadBindings, replyTypingFeedback, discordRestFetch, message, data, threadChannel, ...payload } = ctx;
 	const sanitizedMessage = sanitizeDiscordInboundMessage(message);
 	return {
 		queueKey: resolveDiscordInboundJobQueueKey(ctx),
@@ -78,6 +79,7 @@ function buildDiscordInboundJob(ctx, options) {
 			guildHistories,
 			client,
 			threadBindings,
+			replyTypingFeedback,
 			discordRestFetch
 		},
 		replayKeys: options?.replayKeys ? [...options.replayKeys] : void 0
@@ -118,10 +120,65 @@ function applyImplicitReplyBatchGate(ctx, replyToMode, isBatched) {
 	ctx.ReplyThreading = replyThreading;
 }
 //#endregion
+//#region extensions/discord/src/monitor/message-handler.reply-typing-policy.ts
+function resolveDiscordSourceReplyDeliveryMode(ctx) {
+	return resolveChannelMessageSourceReplyDeliveryMode({
+		cfg: ctx.cfg,
+		ctx: {
+			ChatType: ctx.isDirectMessage ? "direct" : ctx.isGroupDm ? "group" : ctx.isGuildMessage ? "channel" : void 0,
+			InboundEventKind: ctx.inboundEventKind
+		}
+	});
+}
+function resolveDiscordAcceptedTypingPrestart(ctx) {
+	const sourceReplyDeliveryMode = resolveDiscordSourceReplyDeliveryMode(ctx);
+	if (ctx.abortSignal?.aborted) return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: false,
+		reason: "aborted"
+	};
+	if (!ctx.messageText.trim()) return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: false,
+		reason: "empty"
+	};
+	if (ctx.inboundEventKind === "room_event") return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: false,
+		reason: "room-event"
+	};
+	const configuredTypingMode = ctx.cfg.session?.typingMode ?? ctx.cfg.agents?.defaults?.typingMode;
+	if (configuredTypingMode !== void 0) return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: configuredTypingMode === "instant",
+		reason: configuredTypingMode === "instant" ? "configured-instant" : "configured-not-instant"
+	};
+	if (sourceReplyDeliveryMode === "message_tool_only") return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: true,
+		reason: "tool-only"
+	};
+	if (!ctx.isGuildMessage && !ctx.isGroupDm) return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: true,
+		reason: "direct"
+	};
+	if (ctx.effectiveWasMentioned) return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: true,
+		reason: "mentioned-group"
+	};
+	return {
+		sourceReplyDeliveryMode,
+		shouldPrestart: false,
+		reason: "defer-to-message"
+	};
+}
+//#endregion
 //#region extensions/discord/src/monitor/message-run-queue.ts
 let messageProcessRuntimePromise;
 async function loadMessageProcessRuntime() {
-	messageProcessRuntimePromise ??= import("./message-handler.process-B1ODKav3.js");
+	messageProcessRuntimePromise ??= import("./message-handler.process-DJkFWirK.js");
 	return await messageProcessRuntimePromise;
 }
 async function processDiscordQueuedMessage(params) {
@@ -146,8 +203,20 @@ async function processDiscordQueuedMessage(params) {
 		throw error;
 	}
 }
+function cleanupSkippedDiscordQueuedMessage(params) {
+	try {
+		params.job.runtime.replyTypingFeedback?.onCleanup?.();
+	} finally {
+		releaseDiscordInboundReplay({
+			replayKeys: params.job.replayKeys,
+			error: new DiscordRetryableInboundError("discord queued run skipped before processing"),
+			replayGuard: params.replayGuard
+		});
+	}
+}
 function createDiscordMessageRunQueue(params) {
 	const replayGuard = params.replayGuard ?? createDiscordInboundReplayGuard();
+	const skippedCleanup = /* @__PURE__ */ new Set();
 	const runQueue = createChannelRunQueue({
 		setStatus: params.setStatus,
 		abortSignal: params.abortSignal,
@@ -155,9 +224,31 @@ function createDiscordMessageRunQueue(params) {
 			params.runtime.error(danger(`discord message run failed: ${String(error)}`));
 		}
 	});
+	let lifecycleActive = !params.abortSignal?.aborted;
+	const cleanupSkippedQueuedMessages = () => {
+		if (!lifecycleActive && skippedCleanup.size === 0) return;
+		lifecycleActive = false;
+		const cleanups = [...skippedCleanup];
+		skippedCleanup.clear();
+		for (const cleanup of cleanups) cleanup();
+	};
+	if (params.abortSignal?.aborted) cleanupSkippedQueuedMessages();
+	else params.abortSignal?.addEventListener("abort", cleanupSkippedQueuedMessages, { once: true });
 	return {
 		enqueue(job) {
+			const cleanupSkipped = () => {
+				cleanupSkippedDiscordQueuedMessage({
+					job,
+					replayGuard
+				});
+			};
+			if (!lifecycleActive) {
+				cleanupSkipped();
+				return;
+			}
+			skippedCleanup.add(cleanupSkipped);
 			runQueue.enqueue(job.queueKey, async ({ lifecycleSignal }) => {
+				skippedCleanup.delete(cleanupSkipped);
 				await processDiscordQueuedMessage({
 					job,
 					lifecycleSignal,
@@ -166,39 +257,88 @@ function createDiscordMessageRunQueue(params) {
 				});
 			});
 		},
-		deactivate: runQueue.deactivate
+		deactivate() {
+			runQueue.deactivate();
+			cleanupSkippedQueuedMessages();
+		}
+	};
+}
+function createDiscordReplyTypingFeedback(params) {
+	let channelId = params.channelId;
+	const rest = params.rest ?? createDiscordRestClient({
+		cfg: params.cfg,
+		token: params.token,
+		accountId: params.accountId
+	}).rest;
+	const createCallbacks = () => createTypingCallbacks({
+		start: () => sendTyping({
+			rest,
+			channelId
+		}),
+		onStartError: (err) => {
+			logTypingFailure({
+				log: params.log,
+				channel: "discord",
+				target: channelId,
+				error: err
+			});
+		},
+		maxDurationMs: params.maxDurationMs ?? 12e5
+	});
+	const updateChannelId = (nextChannelId) => {
+		const trimmed = nextChannelId.trim();
+		if (trimmed) channelId = trimmed;
+	};
+	let callbacks = createCallbacks();
+	return {
+		onReplyStart: () => callbacks.onReplyStart(),
+		onIdle: () => callbacks.onIdle?.(),
+		onCleanup: () => callbacks.onCleanup?.(),
+		updateChannelId,
+		restartForDispatch: (nextChannelId) => {
+			updateChannelId(nextChannelId);
+			callbacks.onCleanup?.();
+			callbacks = createCallbacks();
+		},
+		getChannelId: () => channelId
 	};
 }
 //#endregion
 //#region extensions/discord/src/monitor/message-handler.ts
 let messagePreflightRuntimePromise;
 async function loadMessagePreflightRuntime() {
-	messagePreflightRuntimePromise ??= import("./message-handler.preflight-B1RTQ6ZO.js");
+	messagePreflightRuntimePromise ??= import("./message-handler.preflight-DeTwc2nk.js");
 	return await messagePreflightRuntimePromise;
 }
 function isNonEmptyString(value) {
 	return typeof value === "string" && value.length > 0;
 }
-function shouldSendAcceptedDiscordTypingCue(ctx) {
-	if (ctx.abortSignal?.aborted) return false;
-	if (!ctx.isDirectMessage || ctx.isGuildMessage || ctx.isGroupDm) return false;
-	if (!ctx.messageText.trim()) return false;
-	const configuredTypingMode = ctx.cfg.session?.typingMode ?? ctx.cfg.agents?.defaults?.typingMode;
-	return configuredTypingMode === void 0 || configuredTypingMode === "instant";
-}
-function queueAcceptedDiscordTypingCue(ctx) {
-	if (!shouldSendAcceptedDiscordTypingCue(ctx)) return;
-	const { rest } = createDiscordRestClient({
+function startAcceptedTypingFeedback(params) {
+	const { ctx, createFeedback, dedupeKey, activeFeedback } = params;
+	if (!resolveDiscordAcceptedTypingPrestart(ctx).shouldPrestart) return;
+	const channelId = ctx.messageChannelId.trim();
+	if (activeFeedback.get(dedupeKey)) return;
+	const replyTypingFeedback = ctx.replyTypingFeedback ?? (createFeedback ?? createDiscordReplyTypingFeedback)({
 		cfg: ctx.cfg,
 		token: ctx.token,
-		accountId: ctx.accountId
+		accountId: ctx.accountId,
+		channelId: ctx.messageChannelId,
+		log: logVerbose
+	});
+	const cleanup = replyTypingFeedback.onCleanup;
+	replyTypingFeedback.onCleanup = () => {
+		cleanup?.();
+		if (activeFeedback.get(dedupeKey)?.feedback === replyTypingFeedback) activeFeedback.delete(dedupeKey);
+	};
+	activeFeedback.set(dedupeKey, {
+		channelId,
+		feedback: replyTypingFeedback
 	});
-	sendTyping({
-		rest,
-		channelId: ctx.messageChannelId
-	}).catch((err) => {
-		logVerbose(`discord early typing cue failed for channel ${ctx.messageChannelId}: ${String(err)}`);
+	ctx.replyTypingFeedback = replyTypingFeedback;
+	replyTypingFeedback.onReplyStart().catch((err) => {
+		logVerbose(`discord accepted typing feedback failed: ${String(err)}`);
 	});
+	return replyTypingFeedback;
 }
 function createDiscordMessageHandler(params) {
 	const { groupPolicy } = resolveOpenProviderRuntimeGroupPolicy({
@@ -209,6 +349,7 @@ function createDiscordMessageHandler(params) {
 	const ackReactionScope = params.discordConfig?.ackReactionScope ?? params.cfg.messages?.ackReactionScope ?? "group-mentions";
 	const preflightDiscordMessageImpl = params.testing?.preflightDiscordMessage;
 	const replayGuard = createDiscordInboundReplayGuard();
+	const prestartedTypingFeedback = /* @__PURE__ */ new Map();
 	const messageRunQueue = createDiscordMessageRunQueue({
 		runtime: params.runtime,
 		setStatus: params.setStatus,
@@ -269,8 +410,14 @@ function createDiscordMessageHandler(params) {
 						});
 						return;
 					}
+					const queueKey = resolveDiscordInboundJobQueueKey(ctx);
+					startAcceptedTypingFeedback({
+						ctx,
+						createFeedback: params.testing?.createReplyTypingFeedback,
+						dedupeKey: queueKey,
+						activeFeedback: prestartedTypingFeedback
+					});
 					applyImplicitReplyBatchGate(ctx, params.replyToMode, false);
-					queueAcceptedDiscordTypingCue(ctx);
 					messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayKeys }));
 					return;
 				}
@@ -322,6 +469,13 @@ function createDiscordMessageHandler(params) {
 					});
 					return;
 				}
+				const queueKey = resolveDiscordInboundJobQueueKey(ctx);
+				startAcceptedTypingFeedback({
+					ctx,
+					createFeedback: params.testing?.createReplyTypingFeedback,
+					dedupeKey: queueKey,
+					activeFeedback: prestartedTypingFeedback
+				});
 				applyImplicitReplyBatchGate(ctx, params.replyToMode, true);
 				if (entries.length > 1) {
 					const ids = entries.map((entry) => entry.data.message?.id).filter(isNonEmptyString);
@@ -332,7 +486,6 @@ function createDiscordMessageHandler(params) {
 						ctxBatch.MessageSidLast = ids[ids.length - 1];
 					}
 				}
-				queueAcceptedDiscordTypingCue(ctx);
 				messageRunQueue.enqueue(buildDiscordInboundJob(ctx, { replayKeys }));
 			} catch (error) {
 				if (error instanceof DiscordRetryableInboundError) releaseDiscordInboundReplay({
@@ -378,4 +531,4 @@ function createDiscordMessageHandler(params) {
 	return handler;
 }
 //#endregion
-export { createDiscordMessageHandler as t };
+export { createDiscordReplyTypingFeedback as n, createDiscordMessageHandler as t };

package/dist/{message-handler.preflight-B1RTQ6ZO.js → message-handler.preflight-DeTwc2nk.js}

@@ -1,12 +1,12 @@
-import { c as discord_exports, k as Message, mt as getChannelMessage } from "./send.receipt-3y2lVFRf.js";
+import { c as discord_exports, k as Message, mt as getChannelMessage } from "./send.receipt-CxFJX9o3.js";
 import { o as resolveDefaultDiscordAccountId } from "./accounts-dXTfmnSZ.js";
 import { S as resolveTimestampMs, _ as resolveGroupDmAllow, a as normalizeDiscordSlug, b as formatDiscordUserTag, c as resolveDiscordChannelConfigWithFallback, d as resolveDiscordGuildEntry, f as resolveDiscordMemberAccessState, g as resolveDiscordShouldRequireMention, i as normalizeDiscordDisplaySlug, n as isDiscordGroupAllowedByPolicy, x as resolveDiscordSystemLocation } from "./allow-list-BnkWtVpA.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-CsPV1Gjx.js";
-import { l as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-BsOnj5NX.js";
-import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-5QgEd_dW.js";
-import "./thread-bindings-BBq-yzq2.js";
-import { D as resolveDiscordTextCommandAccess, E as resolveDiscordDmCommandAccess, _ as resolveDiscordEffectiveRoute, g as resolveDiscordConversationRoute, h as buildDiscordRoutePeer, v as shouldIgnoreStaleDiscordRouteBinding, y as handleDiscordDmCommandDecision } from "./provider-DCcqVFp-.js";
-import { d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-CmB03FoF.js";
+import { t as resolveDiscordConversationIdentity } from "./conversation-identity-Dvi-8LyR.js";
+import { l as isRecentlyUnboundThreadWebhookMessage } from "./thread-bindings.state-B-iprgEM.js";
+import { d as resolveDiscordChannelNameSafe, u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-CItgvv24.js";
+import "./thread-bindings-VrlFUPDW.js";
+import { D as resolveDiscordTextCommandAccess, E as resolveDiscordDmCommandAccess, _ as resolveDiscordEffectiveRoute, g as resolveDiscordConversationRoute, h as buildDiscordRoutePeer, v as shouldIgnoreStaleDiscordRouteBinding, y as handleDiscordDmCommandDecision } from "./provider-SeIwaTTJ.js";
+import { d as resolveDiscordMessageChannelId, l as resolveDiscordMessageStickers, o as resolveMediaList, r as resolveDiscordMessageText, u as resolveDiscordChannelInfo } from "./message-utils-C4OlktSy.js";
 import { n as resolveDiscordWebhookId, t as resolveDiscordSenderIdentity } from "./sender-identity-BFp5w0F8.js";
 import { normalizeOptionalString, readStringValue } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { getChildLogger, logVerbose, shouldLogVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -28,7 +28,7 @@ async function loadConversationRuntime$1() {
 	return await conversationRuntimePromise$1;
 }
 async function loadDiscordSendRuntime() {
-	discordSendRuntimePromise ??= import("./send-CBxhnbKU.js").then((n) => n.t);
+	discordSendRuntimePromise ??= import("./send-DwUf-fzH.js").then((n) => n.t);
 	return await discordSendRuntimePromise;
 }
 async function resolveDiscordDmPreflightAccess(params) {
@@ -423,7 +423,7 @@ let preflightAudioRuntimePromise;
 let systemEventsRuntimePromise;
 let discordThreadingRuntimePromise;
 async function loadPluralKitRuntime() {
-	pluralkitRuntimePromise ??= import("./pluralkit-DAZN3ZMK.js").then((n) => n.n);
+	pluralkitRuntimePromise ??= import("./pluralkit-Dhad974D.js").then((n) => n.n);
 	return await pluralkitRuntimePromise;
 }
 async function loadPreflightAudioRuntime() {
@@ -431,11 +431,11 @@ async function loadPreflightAudioRuntime() {
 	return await preflightAudioRuntimePromise;
 }
 async function loadSystemEventsRuntime() {
-	systemEventsRuntimePromise ??= import("./system-events-Cw6Hp8RF.js");
+	systemEventsRuntimePromise ??= import("./system-events-DZdHRt2j.js");
 	return await systemEventsRuntimePromise;
 }
 async function loadDiscordThreadingRuntime() {
-	discordThreadingRuntimePromise ??= import("./provider-DCcqVFp-.js").then((n) => n.x);
+	discordThreadingRuntimePromise ??= import("./provider-SeIwaTTJ.js").then((n) => n.x);
 	return await discordThreadingRuntimePromise;
 }
 function isPreflightAborted(abortSignal) {

package/dist/{message-handler.process-B1ODKav3.js → message-handler.process-DJkFWirK.js}

@@ -1,17 +1,17 @@
-import { Ut as resolveDiscordChannelId, c as discord_exports, ft as editChannelMessage, s as chunkDiscordTextWithMode, st as createChannelMessage, ut as deleteChannelMessage } from "./send.receipt-3y2lVFRf.js";
+import { Ut as resolveDiscordChannelId, c as discord_exports, ft as editChannelMessage, s as chunkDiscordTextWithMode, st as createChannelMessage, ut as deleteChannelMessage } from "./send.receipt-CxFJX9o3.js";
 import { f as resolveDiscordMaxLinesPerMessage } from "./accounts-dXTfmnSZ.js";
-import { I as createDiscordRestClient, L as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-Ddl21-Gt.js";
+import { I as createDiscordRestClient, L as createDiscordRuntimeAccountContext, _ as resolveDiscordMessageFlags, d as resolveDiscordTargetChannelId } from "./send.shared-DQwyGjXe.js";
 import { S as resolveTimestampMs, a as normalizeDiscordSlug, r as normalizeDiscordAllowList } from "./allow-list-BnkWtVpA.js";
-import { a as removeReactionDiscord, f as editMessageDiscord, r as reactMessageDiscord } from "./send-CBxhnbKU.js";
-import "./targets-BVKF5wbg.js";
-import { t as resolveDiscordConversationIdentity } from "./conversation-identity-CsPV1Gjx.js";
+import { a as removeReactionDiscord, f as editMessageDiscord, r as reactMessageDiscord } from "./send-DwUf-fzH.js";
+import "./targets-xBATI2q7.js";
+import { t as resolveDiscordConversationIdentity } from "./conversation-identity-Dvi-8LyR.js";
 import { t as beginDiscordInboundEventDeliveryCorrelation } from "./inbound-event-delivery-CEPlt2uz.js";
-import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-DfY2Dtf3.js";
+import { t as DISCORD_TEXT_CHUNK_LIMIT } from "./outbound-adapter-DCC3zPuC.js";
 import { t as resolveDiscordPreviewStreamMode } from "./preview-streaming-DXT8oJdo.js";
-import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-l_PsHQvX.js";
-import { S as resolveDiscordAutoThreadReplyPlan, a as resolveReplyContext, i as buildGuildLabel, m as createDiscordSupplementalContextAccessChecker, n as deliverDiscordReply, p as buildDiscordInboundAccessContext, r as buildDirectLabel, w as resolveDiscordThreadStarter } from "./provider-DCcqVFp-.js";
-import { a as resolveForwardedMediaList, o as resolveMediaList, r as resolveDiscordMessageText, s as resolveReferencedReplyMediaList } from "./message-utils-CmB03FoF.js";
-import { t as sendTyping } from "./typing-B7bCMPJJ.js";
+import { n as DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS, t as DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS } from "./timeouts-CEJ3--Uw.js";
+import { S as resolveDiscordAutoThreadReplyPlan, a as resolveReplyContext, i as buildGuildLabel, m as createDiscordSupplementalContextAccessChecker, n as deliverDiscordReply, p as buildDiscordInboundAccessContext, r as buildDirectLabel, w as resolveDiscordThreadStarter } from "./provider-SeIwaTTJ.js";
+import { a as resolveForwardedMediaList, o as resolveMediaList, r as resolveDiscordMessageText, s as resolveReferencedReplyMediaList } from "./message-utils-C4OlktSy.js";
+import { n as createDiscordReplyTypingFeedback } from "./message-handler-Deidymb-.js";
 import { buildAgentSessionKey, normalizeAccountId, resolveAccountEntry, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
 import { MessageFlags } from "discord-api-types/v10";
 import path from "node:path";
@@ -30,7 +30,7 @@ import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";
 import { isDangerousNameMatchingEnabled } from "openclaw/plugin-sdk/dangerous-name-runtime";
 import { loadSessionStore, readLatestAssistantTextFromSessionTranscript, readSessionUpdatedAt, resolveAndPersistSessionFile, resolveSessionStoreEntry, resolveStorePath } from "openclaw/plugin-sdk/session-store-runtime";
 import { buildChannelInboundEventContext, dispatchChannelInboundReply, formatInboundEnvelope, hasFinalInboundReplyDispatch, recordChannelBotPairLoopAndCheckSuppression, resolveEnvelopeFormatOptions, toHistoryMediaEntries, toInboundMediaFacts } from "openclaw/plugin-sdk/channel-inbound";
-import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, logTypingFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
+import { DEFAULT_TIMING, createStatusReactionController, logAckFailure, shouldAckReaction } from "openclaw/plugin-sdk/channel-feedback";
 import { createChannelHistoryWindow } from "openclaw/plugin-sdk/reply-history";
 import { resolveChannelContextVisibilityMode } from "openclaw/plugin-sdk/context-visibility-runtime";
 //#region extensions/discord/src/monitor/ack-reactions.ts
@@ -848,7 +848,6 @@ function sleep(ms) {
 		setTimeout(resolve, ms);
 	});
 }
-const DISCORD_TYPING_MAX_DURATION_MS = 20 * 6e4;
 let replyRuntimePromise;
 async function loadReplyRuntime() {
 	replyRuntimePromise ??= import("openclaw/plugin-sdk/reply-runtime");
@@ -877,8 +876,15 @@ function readToolBooleanArg(args, key) {
 	return args[key] === true;
 }
 async function processDiscordMessage(ctx, observer) {
+	try {
+		await processDiscordMessageInner(ctx, observer);
+	} finally {
+		ctx.replyTypingFeedback?.onCleanup?.();
+	}
+}
+async function processDiscordMessageInner(ctx, observer) {
 	const dispatchStartedAt = Date.now();
-	const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, channelConfig, threadBindings, route, discordRestFetch, abortSignal, botLoopProtection } = ctx;
+	const { cfg, discordConfig, accountId, token, runtime, guildHistories, historyLimit, mediaMaxBytes, textLimit, replyToMode, ackReactionScope, message, messageChannelId, isGuildMessage, isDirectMessage, isGroupDm, messageText, shouldRequireMention, canDetectMention, effectiveWasMentioned, shouldBypassMention, channelConfig, threadBindings, route, discordRestFetch, abortSignal, botLoopProtection, replyTypingFeedback } = ctx;
 	if (isProcessAborted(abortSignal)) return;
 	if (botLoopProtection) {
 		const botLoopResult = recordChannelBotPairLoopAndCheckSuppression(botLoopProtection);
@@ -1050,26 +1056,22 @@ async function processDiscordMessage(ctx, observer) {
 		sessionKey: persistedSessionKey
 	});
 	const typingChannelId = deliverTarget.startsWith("channel:") ? deliverTarget.slice(8) : messageChannelId;
+	const typingFeedback = replyTypingFeedback ?? createDiscordReplyTypingFeedback({
+		cfg,
+		token,
+		accountId,
+		channelId: typingChannelId,
+		rest: feedbackRest,
+		log: logVerbose
+	});
+	if (replyTypingFeedback) replyTypingFeedback.restartForDispatch(typingChannelId);
+	else typingFeedback.updateChannelId(typingChannelId);
 	const { onModelSelected, ...replyPipeline } = createChannelMessageReplyPipeline({
 		cfg,
 		agentId: route.agentId,
 		channel: "discord",
 		accountId: route.accountId,
-		typing: {
-			start: () => sendTyping({
-				rest: feedbackRest,
-				channelId: typingChannelId
-			}),
-			onStartError: (err) => {
-				logTypingFailure({
-					log: logVerbose,
-					channel: "discord",
-					target: typingChannelId,
-					error: err
-				});
-			},
-			maxDurationMs: DISCORD_TYPING_MAX_DURATION_MS
-		}
+		typingCallbacks: typingFeedback
 	});
 	const tableMode = resolveMarkdownTableMode({
 		cfg,

package/dist/{message-utils-CmB03FoF.js → message-utils-C4OlktSy.js}

@@ -1,7 +1,8 @@
-import { u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-5QgEd_dW.js";
-import { a as mergeAbortSignals } from "./timeouts-l_PsHQvX.js";
+import { u as resolveDiscordChannelInfoSafe } from "./thread-bindings.discord-api-CItgvv24.js";
+import { a as mergeAbortSignals } from "./timeouts-CEJ3--Uw.js";
 import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { ComponentType, StickerFormatType } from "discord-api-types/v10";
+import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
 import { saveRemoteMedia } from "openclaw/plugin-sdk/media-runtime";
 import { buildMediaPayload } from "openclaw/plugin-sdk/reply-payload";
 import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
@@ -10,6 +11,16 @@ import { getFileExtension } from "openclaw/plugin-sdk/media-mime";
 const DISCORD_CHANNEL_INFO_CACHE_TTL_MS = 300 * 1e3;
 const DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS = 30 * 1e3;
 const DISCORD_CHANNEL_INFO_CACHE = /* @__PURE__ */ new Map();
+function resolveDiscordChannelInfoCacheExpiresAt(ttlMs, nowMs) {
+	return resolveExpiresAtMsFromDurationMs(ttlMs, { nowMs });
+}
+function cacheDiscordChannelInfo(channelId, value, ttlMs, nowMs) {
+	const expiresAt = resolveDiscordChannelInfoCacheExpiresAt(ttlMs, nowMs);
+	if (expiresAt !== void 0) DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
+		value,
+		expiresAt
+	});
+}
 function normalizeDiscordChannelId(value) {
 	return normalizeOptionalStringifiedId(value) ?? "";
 }
@@ -18,18 +29,17 @@ function resolveDiscordMessageChannelId(params) {
 	return normalizeDiscordChannelId(message.channelId) || normalizeDiscordChannelId(message.channel_id) || normalizeDiscordChannelId(message.rawData?.channel_id) || normalizeDiscordChannelId(params.eventChannelId);
 }
 async function resolveDiscordChannelInfo(client, channelId) {
+	const rawNow = Date.now();
+	const now = asDateTimestampMs(rawNow);
 	const cached = DISCORD_CHANNEL_INFO_CACHE.get(channelId);
 	if (cached) {
-		if (cached.expiresAt > Date.now()) return cached.value;
+		if (now !== void 0 && cached.expiresAt > now) return cached.value;
 		DISCORD_CHANNEL_INFO_CACHE.delete(channelId);
 	}
 	try {
 		const channel = await client.fetchChannel(channelId);
 		if (!channel) {
-			DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
-				value: null,
-				expiresAt: Date.now() + DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS
-			});
+			cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, rawNow);
 			return null;
 		}
 		const channelInfo = resolveDiscordChannelInfoSafe(channel);
@@ -43,17 +53,11 @@ async function resolveDiscordChannelInfo(client, channelId) {
 			parentId: channelInfo.parentId,
 			ownerId: channelInfo.ownerId
 		};
-		DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
-			value: payload,
-			expiresAt: Date.now() + DISCORD_CHANNEL_INFO_CACHE_TTL_MS
-		});
+		cacheDiscordChannelInfo(channelId, payload, DISCORD_CHANNEL_INFO_CACHE_TTL_MS, rawNow);
 		return payload;
 	} catch (err) {
 		logVerbose(`discord: failed to fetch channel ${channelId}: ${String(err)}`);
-		DISCORD_CHANNEL_INFO_CACHE.set(channelId, {
-			value: null,
-			expiresAt: Date.now() + DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS
-		});
+		cacheDiscordChannelInfo(channelId, null, DISCORD_CHANNEL_INFO_NEGATIVE_CACHE_TTL_MS, rawNow);
 		return null;
 	}
 }