remoteclaw 0.1.0-next.2abd2fa → 0.1.0-next.2e9a6cd

package/dist/deliver-D8P9_nk-.js

@@ -0,0 +1,481 @@
+import { t as __exportAll } from "./rolldown-runtime-Cbj13DAv.js";
+import { A as createInternalHookEvent, M as triggerInternalHook, v as getActivePluginRegistry } from "./subsystem-BgxIzx7w.js";
+import { h as normalizeAccountId } from "./session-key-C2n-VILA.js";
+import { t as getAgentScopedMediaLocalRoots } from "./local-roots-BfXsZRkm.js";
+import { a as isRenderablePayload, p as getGlobalHookRunner, s as shouldSuppressReasoningPayload } from "./reply-payloads-te0YnESs.js";
+import { N as appendAssistantMessageToSessionTranscript, P as resolveMirroredTranscriptText } from "./store-Dv76bGHg.js";
+import { c as resolveChunkMode, i as chunkMarkdownTextWithMode, l as resolveTextChunkLimit, n as chunkByParagraph } from "./chunk-C1mQSjas.js";
+import { n as resolveMarkdownTableMode } from "./markdown-tables-xMuH3QnS.js";
+import { t as parseReplyDirectives } from "./reply-directives-Caq4zVTg.js";
+import { a as markdownToSignalTextChunks, t as sendMessageSignal } from "./send-qpwqt34s.js";
+import { i as failDelivery, r as enqueueDelivery, t as ackDelivery } from "./delivery-queue-B6TuHppj.js";
+
+//#region src/channels/plugins/media-limits.ts
+const MB = 1024 * 1024;
+function resolveChannelMediaMaxBytes(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const channelLimit = params.resolveChannelLimitMb({
+		cfg: params.cfg,
+		accountId
+	});
+	if (channelLimit) return channelLimit * MB;
+	if (params.cfg.agents?.defaults?.mediaMaxMb) return params.cfg.agents.defaults.mediaMaxMb * MB;
+}
+
+//#endregion
+//#region src/channels/plugins/registry-loader.ts
+function createChannelRegistryLoader(resolveValue) {
+	const cache = /* @__PURE__ */ new Map();
+	let lastRegistry = null;
+	return async (id) => {
+		const registry = getActivePluginRegistry();
+		if (registry !== lastRegistry) {
+			cache.clear();
+			lastRegistry = registry;
+		}
+		const cached = cache.get(id);
+		if (cached) return cached;
+		const pluginEntry = registry?.channels.find((entry) => entry.plugin.id === id);
+		if (!pluginEntry) return;
+		const resolved = resolveValue(pluginEntry);
+		if (resolved) cache.set(id, resolved);
+		return resolved;
+	};
+}
+
+//#endregion
+//#region src/channels/plugins/outbound/load.ts
+const loadOutboundAdapterFromRegistry = createChannelRegistryLoader((entry) => entry.plugin.outbound);
+async function loadChannelOutboundAdapter(id) {
+	return loadOutboundAdapterFromRegistry(id);
+}
+
+//#endregion
+//#region src/infra/outbound/abort.ts
+/**
+* Utility for checking AbortSignal state and throwing a standard AbortError.
+*/
+/**
+* Throws an AbortError if the given signal has been aborted.
+* Use at async checkpoints to support cancellation.
+*/
+function throwIfAborted(abortSignal) {
+	if (abortSignal?.aborted) {
+		const err = /* @__PURE__ */ new Error("Operation aborted");
+		err.name = "AbortError";
+		throw err;
+	}
+}
+
+//#endregion
+//#region src/infra/outbound/payloads.ts
+function mergeMediaUrls(...lists) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	for (const list of lists) {
+		if (!list) continue;
+		for (const entry of list) {
+			const trimmed = entry?.trim();
+			if (!trimmed) continue;
+			if (seen.has(trimmed)) continue;
+			seen.add(trimmed);
+			merged.push(trimmed);
+		}
+	}
+	return merged;
+}
+function normalizeReplyPayloadsForDelivery(payloads) {
+	return payloads.flatMap((payload) => {
+		if (shouldSuppressReasoningPayload(payload)) return [];
+		const parsed = parseReplyDirectives(payload.text ?? "");
+		const explicitMediaUrls = payload.mediaUrls ?? parsed.mediaUrls;
+		const explicitMediaUrl = payload.mediaUrl ?? parsed.mediaUrl;
+		const mergedMedia = mergeMediaUrls(explicitMediaUrls, explicitMediaUrl ? [explicitMediaUrl] : void 0);
+		const resolvedMediaUrl = (explicitMediaUrls?.length ?? 0) > 1 ? void 0 : explicitMediaUrl;
+		const next = {
+			...payload,
+			text: parsed.text ?? "",
+			mediaUrls: mergedMedia.length ? mergedMedia : void 0,
+			mediaUrl: resolvedMediaUrl,
+			replyToId: payload.replyToId ?? parsed.replyToId,
+			replyToTag: payload.replyToTag || parsed.replyToTag,
+			replyToCurrent: payload.replyToCurrent || parsed.replyToCurrent,
+			audioAsVoice: Boolean(payload.audioAsVoice || parsed.audioAsVoice)
+		};
+		if (parsed.isSilent && mergedMedia.length === 0) return [];
+		if (!isRenderablePayload(next)) return [];
+		return [next];
+	});
+}
+function normalizeOutboundPayloads(payloads) {
+	return normalizeReplyPayloadsForDelivery(payloads).map((payload) => {
+		const channelData = payload.channelData;
+		const normalized = {
+			text: payload.text ?? "",
+			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : [])
+		};
+		if (channelData && Object.keys(channelData).length > 0) normalized.channelData = channelData;
+		return normalized;
+	}).filter((payload) => payload.text || payload.mediaUrls.length > 0 || Boolean(payload.channelData && Object.keys(payload.channelData).length > 0));
+}
+function normalizeOutboundPayloadsForJson(payloads) {
+	return normalizeReplyPayloadsForDelivery(payloads).map((payload) => ({
+		text: payload.text ?? "",
+		mediaUrl: payload.mediaUrl ?? null,
+		mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : void 0),
+		channelData: payload.channelData
+	}));
+}
+function formatOutboundPayloadLog(payload) {
+	const lines = [];
+	if (payload.text) lines.push(payload.text.trimEnd());
+	for (const url of payload.mediaUrls) lines.push(`MEDIA:${url}`);
+	return lines.join("\n");
+}
+
+//#endregion
+//#region src/infra/outbound/deliver.ts
+var deliver_exports = /* @__PURE__ */ __exportAll({ deliverOutboundPayloads: () => deliverOutboundPayloads });
+async function createChannelHandler(params) {
+	const outbound = await loadChannelOutboundAdapter(params.channel);
+	const handler = createPluginHandler({
+		...params,
+		outbound
+	});
+	if (!handler) throw new Error(`Outbound not configured for channel: ${params.channel}`);
+	return handler;
+}
+function createPluginHandler(params) {
+	const outbound = params.outbound;
+	if (!outbound?.sendText || !outbound?.sendMedia) return null;
+	const baseCtx = createChannelOutboundContextBase(params);
+	const sendText = outbound.sendText;
+	const sendMedia = outbound.sendMedia;
+	const chunker = outbound.chunker ?? null;
+	const chunkerMode = outbound.chunkerMode;
+	const resolveCtx = (overrides) => ({
+		...baseCtx,
+		replyToId: overrides?.replyToId ?? baseCtx.replyToId,
+		threadId: overrides?.threadId ?? baseCtx.threadId
+	});
+	return {
+		chunker,
+		chunkerMode,
+		textChunkLimit: outbound.textChunkLimit,
+		sendPayload: outbound.sendPayload ? async (payload, overrides) => outbound.sendPayload({
+			...resolveCtx(overrides),
+			text: payload.text ?? "",
+			mediaUrl: payload.mediaUrl,
+			payload
+		}) : void 0,
+		sendText: async (text, overrides) => sendText({
+			...resolveCtx(overrides),
+			text
+		}),
+		sendMedia: async (caption, mediaUrl, overrides) => sendMedia({
+			...resolveCtx(overrides),
+			text: caption,
+			mediaUrl
+		})
+	};
+}
+function createChannelOutboundContextBase(params) {
+	return {
+		cfg: params.cfg,
+		to: params.to,
+		accountId: params.accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		deps: params.deps,
+		silent: params.silent,
+		mediaLocalRoots: params.mediaLocalRoots
+	};
+}
+const isAbortError = (err) => err instanceof Error && err.name === "AbortError";
+async function deliverOutboundPayloads(params) {
+	const { channel, to, payloads } = params;
+	const queueId = params.skipQueue ? null : await enqueueDelivery({
+		channel,
+		to,
+		accountId: params.accountId,
+		payloads,
+		threadId: params.threadId,
+		replyToId: params.replyToId,
+		bestEffort: params.bestEffort,
+		gifPlayback: params.gifPlayback,
+		silent: params.silent,
+		mirror: params.mirror
+	}).catch(() => null);
+	let hadPartialFailure = false;
+	const wrappedParams = params.onError ? {
+		...params,
+		onError: (err, payload) => {
+			hadPartialFailure = true;
+			params.onError(err, payload);
+		}
+	} : params;
+	try {
+		const results = await deliverOutboundPayloadsCore(wrappedParams);
+		if (queueId) if (hadPartialFailure) await failDelivery(queueId, "partial delivery failure (bestEffort)").catch(() => {});
+		else await ackDelivery(queueId).catch(() => {});
+		return results;
+	} catch (err) {
+		if (queueId) if (isAbortError(err)) await ackDelivery(queueId).catch(() => {});
+		else await failDelivery(queueId, err instanceof Error ? err.message : String(err)).catch(() => {});
+		throw err;
+	}
+}
+/** Core delivery logic (extracted for queue wrapper). */
+async function deliverOutboundPayloadsCore(params) {
+	const { cfg, channel, to, payloads } = params;
+	const accountId = params.accountId;
+	const deps = params.deps;
+	const abortSignal = params.abortSignal;
+	const sendSignal = params.deps?.sendSignal ?? sendMessageSignal;
+	const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, params.agentId ?? params.mirror?.agentId);
+	const results = [];
+	const handler = await createChannelHandler({
+		cfg,
+		channel,
+		to,
+		deps,
+		accountId,
+		replyToId: params.replyToId,
+		threadId: params.threadId,
+		identity: params.identity,
+		gifPlayback: params.gifPlayback,
+		silent: params.silent,
+		mediaLocalRoots
+	});
+	const textLimit = handler.chunker ? resolveTextChunkLimit(cfg, channel, accountId, { fallbackLimit: handler.textChunkLimit }) : void 0;
+	const chunkMode = handler.chunker ? resolveChunkMode(cfg, channel, accountId) : "length";
+	const isSignalChannel = channel === "signal";
+	const signalTableMode = isSignalChannel ? resolveMarkdownTableMode({
+		cfg,
+		channel: "signal",
+		accountId
+	}) : "code";
+	const signalMaxBytes = isSignalChannel ? resolveChannelMediaMaxBytes({
+		cfg,
+		resolveChannelLimitMb: ({ cfg, accountId }) => cfg.channels?.signal?.accounts?.[accountId]?.mediaMaxMb ?? cfg.channels?.signal?.mediaMaxMb,
+		accountId
+	}) : void 0;
+	const sendTextChunks = async (text, overrides) => {
+		throwIfAborted(abortSignal);
+		if (!handler.chunker || textLimit === void 0) {
+			results.push(await handler.sendText(text, overrides));
+			return;
+		}
+		if (chunkMode === "newline") {
+			const blockChunks = (handler.chunkerMode ?? "text") === "markdown" ? chunkMarkdownTextWithMode(text, textLimit, "newline") : chunkByParagraph(text, textLimit);
+			if (!blockChunks.length && text) blockChunks.push(text);
+			for (const blockChunk of blockChunks) {
+				const chunks = handler.chunker(blockChunk, textLimit);
+				if (!chunks.length && blockChunk) chunks.push(blockChunk);
+				for (const chunk of chunks) {
+					throwIfAborted(abortSignal);
+					results.push(await handler.sendText(chunk, overrides));
+				}
+			}
+			return;
+		}
+		const chunks = handler.chunker(text, textLimit);
+		for (const chunk of chunks) {
+			throwIfAborted(abortSignal);
+			results.push(await handler.sendText(chunk, overrides));
+		}
+	};
+	const sendSignalText = async (text, styles) => {
+		throwIfAborted(abortSignal);
+		return {
+			channel: "signal",
+			...await sendSignal(to, text, {
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: styles
+			})
+		};
+	};
+	const sendSignalTextChunks = async (text) => {
+		throwIfAborted(abortSignal);
+		let signalChunks = textLimit === void 0 ? markdownToSignalTextChunks(text, Number.POSITIVE_INFINITY, { tableMode: signalTableMode }) : markdownToSignalTextChunks(text, textLimit, { tableMode: signalTableMode });
+		if (signalChunks.length === 0 && text) signalChunks = [{
+			text,
+			styles: []
+		}];
+		for (const chunk of signalChunks) {
+			throwIfAborted(abortSignal);
+			results.push(await sendSignalText(chunk.text, chunk.styles));
+		}
+	};
+	const sendSignalMedia = async (caption, mediaUrl) => {
+		throwIfAborted(abortSignal);
+		const formatted = markdownToSignalTextChunks(caption, Number.POSITIVE_INFINITY, { tableMode: signalTableMode })[0] ?? {
+			text: caption,
+			styles: []
+		};
+		return {
+			channel: "signal",
+			...await sendSignal(to, formatted.text, {
+				mediaUrl,
+				maxBytes: signalMaxBytes,
+				accountId: accountId ?? void 0,
+				textMode: "plain",
+				textStyles: formatted.styles,
+				mediaLocalRoots
+			})
+		};
+	};
+	const normalizeWhatsAppPayload = (payload) => {
+		const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+		const normalizedText = (typeof payload.text === "string" ? payload.text : "").replace(/^(?:[ \t]*\r?\n)+/, "");
+		if (!normalizedText.trim()) {
+			if (!hasMedia) return null;
+			return {
+				...payload,
+				text: ""
+			};
+		}
+		return {
+			...payload,
+			text: normalizedText
+		};
+	};
+	const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads).flatMap((payload) => {
+		if (channel !== "whatsapp") return [payload];
+		const normalized = normalizeWhatsAppPayload(payload);
+		return normalized ? [normalized] : [];
+	});
+	const hookRunner = getGlobalHookRunner();
+	const sessionKeyForInternalHooks = params.mirror?.sessionKey ?? params.sessionKey;
+	for (const payload of normalizedPayloads) {
+		const payloadSummary = {
+			text: payload.text ?? "",
+			mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
+			channelData: payload.channelData
+		};
+		const emitMessageSent = (params) => {
+			if (hookRunner?.hasHooks("message_sent")) hookRunner.runMessageSent({
+				to,
+				content: params.content,
+				success: params.success,
+				...params.error ? { error: params.error } : {}
+			}, {
+				channelId: channel,
+				accountId: accountId ?? void 0,
+				conversationId: to
+			}).catch(() => {});
+			if (!sessionKeyForInternalHooks) return;
+			triggerInternalHook(createInternalHookEvent("message", "sent", sessionKeyForInternalHooks, {
+				to,
+				content: params.content,
+				success: params.success,
+				...params.error ? { error: params.error } : {},
+				channelId: channel,
+				accountId: accountId ?? void 0,
+				conversationId: to,
+				messageId: params.messageId
+			})).catch(() => {});
+		};
+		try {
+			throwIfAborted(abortSignal);
+			let effectivePayload = payload;
+			if (hookRunner?.hasHooks("message_sending")) try {
+				const sendingResult = await hookRunner.runMessageSending({
+					to,
+					content: payloadSummary.text,
+					metadata: {
+						channel,
+						accountId,
+						mediaUrls: payloadSummary.mediaUrls
+					}
+				}, {
+					channelId: channel,
+					accountId: accountId ?? void 0
+				});
+				if (sendingResult?.cancel) continue;
+				if (sendingResult?.content != null) {
+					effectivePayload = {
+						...payload,
+						text: sendingResult.content
+					};
+					payloadSummary.text = sendingResult.content;
+				}
+			} catch {}
+			params.onPayload?.(payloadSummary);
+			const sendOverrides = {
+				replyToId: effectivePayload.replyToId ?? params.replyToId ?? void 0,
+				threadId: params.threadId ?? void 0
+			};
+			if (handler.sendPayload && effectivePayload.channelData) {
+				const delivery = await handler.sendPayload(effectivePayload, sendOverrides);
+				results.push(delivery);
+				emitMessageSent({
+					success: true,
+					content: payloadSummary.text,
+					messageId: delivery.messageId
+				});
+				continue;
+			}
+			if (payloadSummary.mediaUrls.length === 0) {
+				const beforeCount = results.length;
+				if (isSignalChannel) await sendSignalTextChunks(payloadSummary.text);
+				else await sendTextChunks(payloadSummary.text, sendOverrides);
+				const messageId = results.at(-1)?.messageId;
+				emitMessageSent({
+					success: results.length > beforeCount,
+					content: payloadSummary.text,
+					messageId
+				});
+				continue;
+			}
+			let first = true;
+			let lastMessageId;
+			for (const url of payloadSummary.mediaUrls) {
+				throwIfAborted(abortSignal);
+				const caption = first ? payloadSummary.text : "";
+				first = false;
+				if (isSignalChannel) {
+					const delivery = await sendSignalMedia(caption, url);
+					results.push(delivery);
+					lastMessageId = delivery.messageId;
+				} else {
+					const delivery = await handler.sendMedia(caption, url, sendOverrides);
+					results.push(delivery);
+					lastMessageId = delivery.messageId;
+				}
+			}
+			emitMessageSent({
+				success: true,
+				content: payloadSummary.text,
+				messageId: lastMessageId
+			});
+		} catch (err) {
+			emitMessageSent({
+				success: false,
+				content: payloadSummary.text,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			if (!params.bestEffort) throw err;
+			params.onError?.(err, payloadSummary);
+		}
+	}
+	if (params.mirror && results.length > 0) {
+		const mirrorText = resolveMirroredTranscriptText({
+			text: params.mirror.text,
+			mediaUrls: params.mirror.mediaUrls
+		});
+		if (mirrorText) await appendAssistantMessageToSessionTranscript({
+			agentId: params.mirror.agentId,
+			sessionKey: params.mirror.sessionKey,
+			text: mirrorText
+		});
+	}
+	return results;
+}
+
+//#endregion
+export { normalizeOutboundPayloadsForJson as a, normalizeOutboundPayloads as i, deliver_exports as n, normalizeReplyPayloadsForDelivery as o, formatOutboundPayloadLog as r, throwIfAborted as s, deliverOutboundPayloads as t };