remoteclaw 0.1.0-next.da482d8 → 0.1.0-next.db8a792

package/dist/provider-dispatcher-D5Q7M15D.js

@@ -0,0 +1,660 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { M as shouldLogVerbose, k as logVerbose, x as sleep } from "./utils-C5daYcFn.js";
+import { D as tryFastAbortFromMessage, ct as maybeApplyTtsToPayload, ft as resolveTtsConfig, lt as normalizeTtsAutoMode, t as getReplyFromConfig, w as formatAbortReplyText } from "./reply-DZMooMoq.js";
+import { A as createInternalHookEvent, M as triggerInternalHook } from "./subsystem-m7RSGQoR.js";
+import { l as resolveSessionAgentId } from "./agent-scope-DVvX_nkQ.js";
+import { J as routeReply, Y as normalizeReplyPayload, at as logMessageQueued, it as logMessageProcessed, ot as logSessionStateChange, pt as isDiagnosticsEnabled, q as isRoutableChannel } from "./subagent-registry-DNAz7Heu.js";
+import { p as getGlobalHookRunner, s as shouldSuppressReasoningPayload } from "./reply-payloads-BospFSPI.js";
+import { m as resolveStorePath } from "./chat-envelope-DUMcMMB2.js";
+import { n as loadSessionStore } from "./store-Bnm6zwaq.js";
+import { t as finalizeInboundContext } from "./inbound-context-COwswi8z.js";
+
+//#region src/infra/map-size.ts
+function pruneMapToMaxSize(map, maxSize) {
+	const limit = Math.max(0, Math.floor(maxSize));
+	if (limit <= 0) {
+		map.clear();
+		return;
+	}
+	while (map.size > limit) {
+		const oldest = map.keys().next();
+		if (oldest.done) break;
+		map.delete(oldest.value);
+	}
+}
+
+//#endregion
+//#region src/infra/dedupe.ts
+function createDedupeCache(options) {
+	const ttlMs = Math.max(0, options.ttlMs);
+	const maxSize = Math.max(0, Math.floor(options.maxSize));
+	const cache = /* @__PURE__ */ new Map();
+	const touch = (key, now) => {
+		cache.delete(key);
+		cache.set(key, now);
+	};
+	const prune = (now) => {
+		const cutoff = ttlMs > 0 ? now - ttlMs : void 0;
+		if (cutoff !== void 0) {
+			for (const [entryKey, entryTs] of cache) if (entryTs < cutoff) cache.delete(entryKey);
+		}
+		if (maxSize <= 0) {
+			cache.clear();
+			return;
+		}
+		pruneMapToMaxSize(cache, maxSize);
+	};
+	const hasUnexpired = (key, now, touchOnRead) => {
+		const existing = cache.get(key);
+		if (existing === void 0) return false;
+		if (ttlMs > 0 && now - existing >= ttlMs) {
+			cache.delete(key);
+			return false;
+		}
+		if (touchOnRead) touch(key, now);
+		return true;
+	};
+	return {
+		check: (key, now = Date.now()) => {
+			if (!key) return false;
+			if (hasUnexpired(key, now, true)) return true;
+			touch(key, now);
+			prune(now);
+			return false;
+		},
+		peek: (key, now = Date.now()) => {
+			if (!key) return false;
+			return hasUnexpired(key, now, false);
+		},
+		clear: () => {
+			cache.clear();
+		},
+		size: () => cache.size
+	};
+}
+
+//#endregion
+//#region src/auto-reply/reply/inbound-dedupe.ts
+const inboundDedupeCache = createDedupeCache({
+	ttlMs: 20 * 6e4,
+	maxSize: 5e3
+});
+const normalizeProvider = (value) => value?.trim().toLowerCase() || "";
+const resolveInboundPeerId = (ctx) => ctx.OriginatingTo ?? ctx.To ?? ctx.From ?? ctx.SessionKey;
+function buildInboundDedupeKey(ctx) {
+	const provider = normalizeProvider(ctx.OriginatingChannel ?? ctx.Provider ?? ctx.Surface);
+	const messageId = ctx.MessageSid?.trim();
+	if (!provider || !messageId) return null;
+	const peerId = resolveInboundPeerId(ctx);
+	if (!peerId) return null;
+	const sessionKey = ctx.SessionKey?.trim() ?? "";
+	return [
+		provider,
+		ctx.AccountId?.trim() ?? "",
+		sessionKey,
+		peerId,
+		ctx.MessageThreadId !== void 0 && ctx.MessageThreadId !== null ? String(ctx.MessageThreadId) : "",
+		messageId
+	].filter(Boolean).join("|");
+}
+function shouldSkipDuplicateInbound(ctx, opts) {
+	const key = buildInboundDedupeKey(ctx);
+	if (!key) return false;
+	const skipped = (opts?.cache ?? inboundDedupeCache).check(key, opts?.now);
+	if (skipped && shouldLogVerbose()) logVerbose(`inbound dedupe: skipped ${key}`);
+	return skipped;
+}
+
+//#endregion
+//#region src/auto-reply/reply/dispatch-from-config.ts
+const AUDIO_PLACEHOLDER_RE = /^<media:audio>(\s*\([^)]*\))?$/i;
+const AUDIO_HEADER_RE = /^\[Audio\b/i;
+const normalizeMediaType = (value) => value.split(";")[0]?.trim().toLowerCase();
+const isInboundAudioContext = (ctx) => {
+	if ([typeof ctx.MediaType === "string" ? ctx.MediaType : void 0, ...Array.isArray(ctx.MediaTypes) ? ctx.MediaTypes : []].filter(Boolean).map((type) => normalizeMediaType(type)).some((type) => type === "audio" || type.startsWith("audio/"))) return true;
+	const trimmed = (typeof ctx.BodyForCommands === "string" ? ctx.BodyForCommands : typeof ctx.CommandBody === "string" ? ctx.CommandBody : typeof ctx.RawBody === "string" ? ctx.RawBody : typeof ctx.Body === "string" ? ctx.Body : "").trim();
+	if (!trimmed) return false;
+	if (AUDIO_PLACEHOLDER_RE.test(trimmed)) return true;
+	return AUDIO_HEADER_RE.test(trimmed);
+};
+const resolveSessionTtsAuto = (ctx, cfg) => {
+	const sessionKey = ((ctx.CommandSource === "native" ? ctx.CommandTargetSessionKey?.trim() : void 0) ?? ctx.SessionKey)?.trim();
+	if (!sessionKey) return;
+	const agentId = resolveSessionAgentId({
+		sessionKey,
+		config: cfg
+	});
+	const storePath = resolveStorePath(cfg.session?.store, { agentId });
+	try {
+		const store = loadSessionStore(storePath);
+		return normalizeTtsAutoMode((store[sessionKey.toLowerCase()] ?? store[sessionKey])?.ttsAuto);
+	} catch {
+		return;
+	}
+};
+async function dispatchReplyFromConfig(params) {
+	const { ctx, cfg, dispatcher } = params;
+	const diagnosticsEnabled = isDiagnosticsEnabled(cfg);
+	const channel = String(ctx.Surface ?? ctx.Provider ?? "unknown").toLowerCase();
+	const chatId = ctx.To ?? ctx.From;
+	const messageId = ctx.MessageSid ?? ctx.MessageSidFirst ?? ctx.MessageSidLast;
+	const sessionKey = ctx.SessionKey;
+	const startTime = diagnosticsEnabled ? Date.now() : 0;
+	const canTrackSession = diagnosticsEnabled && Boolean(sessionKey);
+	const recordProcessed = (outcome, opts) => {
+		if (!diagnosticsEnabled) return;
+		logMessageProcessed({
+			channel,
+			chatId,
+			messageId,
+			sessionKey,
+			durationMs: Date.now() - startTime,
+			outcome,
+			reason: opts?.reason,
+			error: opts?.error
+		});
+	};
+	const markProcessing = () => {
+		if (!canTrackSession || !sessionKey) return;
+		logMessageQueued({
+			sessionKey,
+			channel,
+			source: "dispatch"
+		});
+		logSessionStateChange({
+			sessionKey,
+			state: "processing",
+			reason: "message_start"
+		});
+	};
+	const markIdle = (reason) => {
+		if (!canTrackSession || !sessionKey) return;
+		logSessionStateChange({
+			sessionKey,
+			state: "idle",
+			reason
+		});
+	};
+	if (shouldSkipDuplicateInbound(ctx)) {
+		recordProcessed("skipped", { reason: "duplicate" });
+		return {
+			queuedFinal: false,
+			counts: dispatcher.getQueuedCounts()
+		};
+	}
+	const inboundAudio = isInboundAudioContext(ctx);
+	const sessionTtsAuto = resolveSessionTtsAuto(ctx, cfg);
+	const hookRunner = getGlobalHookRunner();
+	const timestamp = typeof ctx.Timestamp === "number" && Number.isFinite(ctx.Timestamp) ? ctx.Timestamp : void 0;
+	const messageIdForHook = ctx.MessageSidFull ?? ctx.MessageSid ?? ctx.MessageSidFirst ?? ctx.MessageSidLast;
+	const content = typeof ctx.BodyForCommands === "string" ? ctx.BodyForCommands : typeof ctx.RawBody === "string" ? ctx.RawBody : typeof ctx.Body === "string" ? ctx.Body : "";
+	const channelId = (ctx.OriginatingChannel ?? ctx.Surface ?? ctx.Provider ?? "").toLowerCase();
+	const conversationId = ctx.OriginatingTo ?? ctx.To ?? ctx.From ?? void 0;
+	if (hookRunner?.hasHooks("message_received")) hookRunner.runMessageReceived({
+		from: ctx.From ?? "",
+		content,
+		timestamp,
+		metadata: {
+			to: ctx.To,
+			provider: ctx.Provider,
+			surface: ctx.Surface,
+			threadId: ctx.MessageThreadId,
+			originatingChannel: ctx.OriginatingChannel,
+			originatingTo: ctx.OriginatingTo,
+			messageId: messageIdForHook,
+			senderId: ctx.SenderId,
+			senderName: ctx.SenderName,
+			senderUsername: ctx.SenderUsername,
+			senderE164: ctx.SenderE164,
+			guildId: ctx.GroupSpace,
+			channelName: ctx.GroupChannel
+		}
+	}, {
+		channelId,
+		accountId: ctx.AccountId,
+		conversationId
+	}).catch((err) => {
+		logVerbose(`dispatch-from-config: message_received plugin hook failed: ${String(err)}`);
+	});
+	if (sessionKey) triggerInternalHook(createInternalHookEvent("message", "received", sessionKey, {
+		from: ctx.From ?? "",
+		content,
+		timestamp,
+		channelId,
+		accountId: ctx.AccountId,
+		conversationId,
+		messageId: messageIdForHook,
+		metadata: {
+			to: ctx.To,
+			provider: ctx.Provider,
+			surface: ctx.Surface,
+			threadId: ctx.MessageThreadId,
+			senderId: ctx.SenderId,
+			senderName: ctx.SenderName,
+			senderUsername: ctx.SenderUsername,
+			senderE164: ctx.SenderE164,
+			guildId: ctx.GroupSpace,
+			channelName: ctx.GroupChannel
+		}
+	})).catch((err) => {
+		logVerbose(`dispatch-from-config: message_received internal hook failed: ${String(err)}`);
+	});
+	const originatingChannel = ctx.OriginatingChannel;
+	const originatingTo = ctx.OriginatingTo;
+	const currentSurface = (ctx.Surface ?? ctx.Provider)?.toLowerCase();
+	const shouldRouteToOriginating = isRoutableChannel(originatingChannel) && originatingTo && originatingChannel !== currentSurface;
+	const ttsChannel = shouldRouteToOriginating ? originatingChannel : currentSurface;
+	/**
+	* Helper to send a payload via route-reply (async).
+	* Only used when actually routing to a different provider.
+	* Note: Only called when shouldRouteToOriginating is true, so
+	* originatingChannel and originatingTo are guaranteed to be defined.
+	*/
+	const sendPayloadAsync = async (payload, abortSignal, mirror) => {
+		if (!originatingChannel || !originatingTo) return;
+		if (abortSignal?.aborted) return;
+		const result = await routeReply({
+			payload,
+			channel: originatingChannel,
+			to: originatingTo,
+			sessionKey: ctx.SessionKey,
+			accountId: ctx.AccountId,
+			threadId: ctx.MessageThreadId,
+			cfg,
+			abortSignal,
+			mirror
+		});
+		if (!result.ok) logVerbose(`dispatch-from-config: route-reply failed: ${result.error ?? "unknown error"}`);
+	};
+	markProcessing();
+	try {
+		const fastAbort = await tryFastAbortFromMessage({
+			ctx,
+			cfg
+		});
+		if (fastAbort.handled) {
+			const payload = { text: formatAbortReplyText(fastAbort.stoppedSubagents) };
+			let queuedFinal = false;
+			let routedFinalCount = 0;
+			if (shouldRouteToOriginating && originatingChannel && originatingTo) {
+				const result = await routeReply({
+					payload,
+					channel: originatingChannel,
+					to: originatingTo,
+					sessionKey: ctx.SessionKey,
+					accountId: ctx.AccountId,
+					threadId: ctx.MessageThreadId,
+					cfg
+				});
+				queuedFinal = result.ok;
+				if (result.ok) routedFinalCount += 1;
+				if (!result.ok) logVerbose(`dispatch-from-config: route-reply (abort) failed: ${result.error ?? "unknown error"}`);
+			} else queuedFinal = dispatcher.sendFinalReply(payload);
+			const counts = dispatcher.getQueuedCounts();
+			counts.final += routedFinalCount;
+			recordProcessed("completed", { reason: "fast_abort" });
+			markIdle("message_completed");
+			return {
+				queuedFinal,
+				counts
+			};
+		}
+		let accumulatedBlockText = "";
+		let blockCount = 0;
+		const shouldSendToolSummaries = ctx.ChatType !== "group" && ctx.CommandSource !== "native";
+		const resolveToolDeliveryPayload = (payload) => {
+			if (shouldSendToolSummaries) return payload;
+			if (!(Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0)) return null;
+			return {
+				...payload,
+				text: void 0
+			};
+		};
+		const replyResult = await (params.replyResolver ?? getReplyFromConfig)(ctx, {
+			...params.replyOptions,
+			onToolResult: (payload) => {
+				const run = async () => {
+					const deliveryPayload = resolveToolDeliveryPayload(await maybeApplyTtsToPayload({
+						payload,
+						cfg,
+						channel: ttsChannel,
+						kind: "tool",
+						inboundAudio,
+						ttsAuto: sessionTtsAuto
+					}));
+					if (!deliveryPayload) return;
+					if (shouldRouteToOriginating) await sendPayloadAsync(deliveryPayload, void 0, false);
+					else dispatcher.sendToolResult(deliveryPayload);
+				};
+				return run();
+			},
+			onBlockReply: (payload, context) => {
+				const run = async () => {
+					if (shouldSuppressReasoningPayload(payload)) return;
+					if (payload.text) {
+						if (accumulatedBlockText.length > 0) accumulatedBlockText += "\n";
+						accumulatedBlockText += payload.text;
+						blockCount++;
+					}
+					const ttsPayload = await maybeApplyTtsToPayload({
+						payload,
+						cfg,
+						channel: ttsChannel,
+						kind: "block",
+						inboundAudio,
+						ttsAuto: sessionTtsAuto
+					});
+					if (shouldRouteToOriginating) await sendPayloadAsync(ttsPayload, context?.abortSignal, false);
+					else dispatcher.sendBlockReply(ttsPayload);
+				};
+				return run();
+			}
+		}, cfg);
+		const replies = replyResult ? Array.isArray(replyResult) ? replyResult : [replyResult] : [];
+		let queuedFinal = false;
+		let routedFinalCount = 0;
+		for (const reply of replies) {
+			if (shouldSuppressReasoningPayload(reply)) continue;
+			const ttsReply = await maybeApplyTtsToPayload({
+				payload: reply,
+				cfg,
+				channel: ttsChannel,
+				kind: "final",
+				inboundAudio,
+				ttsAuto: sessionTtsAuto
+			});
+			if (shouldRouteToOriginating && originatingChannel && originatingTo) {
+				const result = await routeReply({
+					payload: ttsReply,
+					channel: originatingChannel,
+					to: originatingTo,
+					sessionKey: ctx.SessionKey,
+					accountId: ctx.AccountId,
+					threadId: ctx.MessageThreadId,
+					cfg
+				});
+				if (!result.ok) logVerbose(`dispatch-from-config: route-reply (final) failed: ${result.error ?? "unknown error"}`);
+				queuedFinal = result.ok || queuedFinal;
+				if (result.ok) routedFinalCount += 1;
+			} else queuedFinal = dispatcher.sendFinalReply(ttsReply) || queuedFinal;
+		}
+		if ((resolveTtsConfig(cfg).mode ?? "final") === "final" && replies.length === 0 && blockCount > 0 && accumulatedBlockText.trim()) try {
+			const ttsSyntheticReply = await maybeApplyTtsToPayload({
+				payload: { text: accumulatedBlockText },
+				cfg,
+				channel: ttsChannel,
+				kind: "final",
+				inboundAudio,
+				ttsAuto: sessionTtsAuto
+			});
+			if (ttsSyntheticReply.mediaUrl) {
+				const ttsOnlyPayload = {
+					mediaUrl: ttsSyntheticReply.mediaUrl,
+					audioAsVoice: ttsSyntheticReply.audioAsVoice
+				};
+				if (shouldRouteToOriginating && originatingChannel && originatingTo) {
+					const result = await routeReply({
+						payload: ttsOnlyPayload,
+						channel: originatingChannel,
+						to: originatingTo,
+						sessionKey: ctx.SessionKey,
+						accountId: ctx.AccountId,
+						threadId: ctx.MessageThreadId,
+						cfg
+					});
+					queuedFinal = result.ok || queuedFinal;
+					if (result.ok) routedFinalCount += 1;
+					if (!result.ok) logVerbose(`dispatch-from-config: route-reply (tts-only) failed: ${result.error ?? "unknown error"}`);
+				} else queuedFinal = dispatcher.sendFinalReply(ttsOnlyPayload) || queuedFinal;
+			}
+		} catch (err) {
+			logVerbose(`dispatch-from-config: accumulated block TTS failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		const counts = dispatcher.getQueuedCounts();
+		counts.final += routedFinalCount;
+		recordProcessed("completed");
+		markIdle("message_completed");
+		return {
+			queuedFinal,
+			counts
+		};
+	} catch (err) {
+		recordProcessed("error", { error: String(err) });
+		markIdle("message_error");
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/auto-reply/reply/dispatcher-registry.ts
+const activeDispatchers = /* @__PURE__ */ new Set();
+let nextId = 0;
+/**
+* Register a reply dispatcher for global tracking.
+* Returns an unregister function to call when the dispatcher is no longer needed.
+*/
+function registerDispatcher(dispatcher) {
+	const id = `dispatcher-${++nextId}`;
+	const tracked = {
+		id,
+		pending: dispatcher.pending,
+		waitForIdle: dispatcher.waitForIdle
+	};
+	activeDispatchers.add(tracked);
+	const unregister = () => {
+		activeDispatchers.delete(tracked);
+	};
+	return {
+		id,
+		unregister
+	};
+}
+/**
+* Get the total number of pending replies across all dispatchers.
+*/
+function getTotalPendingReplies() {
+	let total = 0;
+	for (const dispatcher of activeDispatchers) total += dispatcher.pending();
+	return total;
+}
+
+//#endregion
+//#region src/auto-reply/reply/reply-dispatcher.ts
+const DEFAULT_HUMAN_DELAY_MIN_MS = 800;
+const DEFAULT_HUMAN_DELAY_MAX_MS = 2500;
+/** Generate a random delay within the configured range. */
+function getHumanDelay(config) {
+	const mode = config?.mode ?? "off";
+	if (mode === "off") return 0;
+	const min = mode === "custom" ? config?.minMs ?? DEFAULT_HUMAN_DELAY_MIN_MS : DEFAULT_HUMAN_DELAY_MIN_MS;
+	const max = mode === "custom" ? config?.maxMs ?? DEFAULT_HUMAN_DELAY_MAX_MS : DEFAULT_HUMAN_DELAY_MAX_MS;
+	if (max <= min) return min;
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+function normalizeReplyPayloadInternal(payload, opts) {
+	const prefixContext = opts.responsePrefixContextProvider?.() ?? opts.responsePrefixContext;
+	return normalizeReplyPayload(payload, {
+		responsePrefix: opts.responsePrefix,
+		responsePrefixContext: prefixContext,
+		onSkip: opts.onSkip
+	});
+}
+function createReplyDispatcher(options) {
+	let sendChain = Promise.resolve();
+	let pending = 1;
+	let completeCalled = false;
+	let sentFirstBlock = false;
+	const queuedCounts = {
+		tool: 0,
+		block: 0,
+		final: 0
+	};
+	const { unregister } = registerDispatcher({
+		pending: () => pending,
+		waitForIdle: () => sendChain
+	});
+	const enqueue = (kind, payload) => {
+		const normalized = normalizeReplyPayloadInternal(payload, {
+			responsePrefix: options.responsePrefix,
+			responsePrefixContext: options.responsePrefixContext,
+			responsePrefixContextProvider: options.responsePrefixContextProvider,
+			onSkip: (reason) => options.onSkip?.(payload, {
+				kind,
+				reason
+			})
+		});
+		if (!normalized) return false;
+		queuedCounts[kind] += 1;
+		pending += 1;
+		const shouldDelay = kind === "block" && sentFirstBlock;
+		if (kind === "block") sentFirstBlock = true;
+		sendChain = sendChain.then(async () => {
+			if (shouldDelay) {
+				const delayMs = getHumanDelay(options.humanDelay);
+				if (delayMs > 0) await sleep(delayMs);
+			}
+			await options.deliver(normalized, { kind });
+		}).catch((err) => {
+			options.onError?.(err, { kind });
+		}).finally(() => {
+			pending -= 1;
+			if (pending === 1 && completeCalled) pending -= 1;
+			if (pending === 0) {
+				unregister();
+				options.onIdle?.();
+			}
+		});
+		return true;
+	};
+	const markComplete = () => {
+		if (completeCalled) return;
+		completeCalled = true;
+		Promise.resolve().then(() => {
+			if (pending === 1 && completeCalled) {
+				pending -= 1;
+				if (pending === 0) {
+					unregister();
+					options.onIdle?.();
+				}
+			}
+		});
+	};
+	return {
+		sendToolResult: (payload) => enqueue("tool", payload),
+		sendBlockReply: (payload) => enqueue("block", payload),
+		sendFinalReply: (payload) => enqueue("final", payload),
+		waitForIdle: () => sendChain,
+		getQueuedCounts: () => ({ ...queuedCounts }),
+		markComplete
+	};
+}
+function createReplyDispatcherWithTyping(options) {
+	const { typingCallbacks, onReplyStart, onIdle, onCleanup, ...dispatcherOptions } = options;
+	const resolvedOnReplyStart = onReplyStart ?? typingCallbacks?.onReplyStart;
+	const resolvedOnIdle = onIdle ?? typingCallbacks?.onIdle;
+	const resolvedOnCleanup = onCleanup ?? typingCallbacks?.onCleanup;
+	let typingController;
+	return {
+		dispatcher: createReplyDispatcher({
+			...dispatcherOptions,
+			onIdle: () => {
+				typingController?.markDispatchIdle();
+				resolvedOnIdle?.();
+			}
+		}),
+		replyOptions: {
+			onReplyStart: resolvedOnReplyStart,
+			onTypingCleanup: resolvedOnCleanup,
+			onTypingController: (typing) => {
+				typingController = typing;
+			}
+		},
+		markDispatchIdle: () => {
+			typingController?.markDispatchIdle();
+			resolvedOnIdle?.();
+		}
+	};
+}
+
+//#endregion
+//#region src/auto-reply/dispatch.ts
+async function withReplyDispatcher(params) {
+	try {
+		return await params.run();
+	} finally {
+		params.dispatcher.markComplete();
+		try {
+			await params.dispatcher.waitForIdle();
+		} finally {
+			await params.onSettled?.();
+		}
+	}
+}
+async function dispatchInboundMessage(params) {
+	const finalized = finalizeInboundContext(params.ctx);
+	return await withReplyDispatcher({
+		dispatcher: params.dispatcher,
+		run: () => dispatchReplyFromConfig({
+			ctx: finalized,
+			cfg: params.cfg,
+			dispatcher: params.dispatcher,
+			replyOptions: params.replyOptions,
+			replyResolver: params.replyResolver
+		})
+	});
+}
+async function dispatchInboundMessageWithBufferedDispatcher(params) {
+	const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping(params.dispatcherOptions);
+	try {
+		return await dispatchInboundMessage({
+			ctx: params.ctx,
+			cfg: params.cfg,
+			dispatcher,
+			replyResolver: params.replyResolver,
+			replyOptions: {
+				...params.replyOptions,
+				...replyOptions
+			}
+		});
+	} finally {
+		markDispatchIdle();
+	}
+}
+async function dispatchInboundMessageWithDispatcher(params) {
+	const dispatcher = createReplyDispatcher(params.dispatcherOptions);
+	return await dispatchInboundMessage({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		dispatcher,
+		replyResolver: params.replyResolver,
+		replyOptions: params.replyOptions
+	});
+}
+
+//#endregion
+//#region src/auto-reply/reply/provider-dispatcher.ts
+var provider_dispatcher_exports = /* @__PURE__ */ __exportAll({
+	dispatchReplyWithBufferedBlockDispatcher: () => dispatchReplyWithBufferedBlockDispatcher,
+	dispatchReplyWithDispatcher: () => dispatchReplyWithDispatcher
+});
+async function dispatchReplyWithBufferedBlockDispatcher(params) {
+	return await dispatchInboundMessageWithBufferedDispatcher({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		dispatcherOptions: params.dispatcherOptions,
+		replyResolver: params.replyResolver,
+		replyOptions: params.replyOptions
+	});
+}
+async function dispatchReplyWithDispatcher(params) {
+	return await dispatchInboundMessageWithDispatcher({
+		ctx: params.ctx,
+		cfg: params.cfg,
+		dispatcherOptions: params.dispatcherOptions,
+		replyResolver: params.replyResolver,
+		replyOptions: params.replyOptions
+	});
+}
+
+//#endregion
+export { createReplyDispatcher as a, dispatchReplyFromConfig as c, dispatchInboundMessage as i, createDedupeCache as l, dispatchReplyWithDispatcher as n, createReplyDispatcherWithTyping as o, provider_dispatcher_exports as r, getTotalPendingReplies as s, dispatchReplyWithBufferedBlockDispatcher as t, pruneMapToMaxSize as u };