@openclaw/matrix 2026.9.5 → 2026.9.7

package/dist/.setup/outbound-DRWtSUe-.mjs

@@ -1,228 +0,0 @@
-import { i as sendPollMatrix, r as sendMessageMatrix } from "./send-h0gZ_-qk.mjs";
-import { createMessageReceiptFromOutboundResults, createReplyToFanout, resolveOutboundSendDep } from "openclaw/plugin-sdk/channel-outbound";
-import { asOptionalRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { chunkTextForOutbound } from "openclaw/plugin-sdk/text-chunking";
-import { attachChannelToResult } from "openclaw/plugin-sdk/channel-send-result";
-import { renderMessagePresentationFallbackText, renderPresentationForDelivery } from "openclaw/plugin-sdk/interactive-runtime";
-import { resolveSendableOutboundReplyParts, sendPayloadMediaSequence } from "openclaw/plugin-sdk/reply-payload";
-//#region extensions/matrix/src/outbound.ts
-const MATRIX_OPENCLAW_PRESENTATION_KEY = "com.openclaw.presentation";
-const MATRIX_OPENCLAW_PRESENTATION_TYPE = "message.presentation";
-const MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT = "---";
-const MATRIX_PRESENTATION_CAPABILITIES = {
-	supported: true,
-	buttons: true,
-	selects: true,
-	context: true,
-	divider: true,
-	limits: { text: {
-		markdownDialect: "markdown",
-		supportsEdit: true
-	} }
-};
-function toMatrixOutboundResult(result) {
-	const { roomId, ...delivery } = result;
-	return {
-		...delivery,
-		target: {
-			kind: "room",
-			id: roomId
-		}
-	};
-}
-function resolveMatrixChannelData(payload) {
-	const raw = asOptionalRecord(payload.channelData)?.matrix;
-	return asOptionalRecord(raw) ?? {};
-}
-function buildMatrixPresentationContent(presentation) {
-	return {
-		...presentation,
-		version: 1,
-		type: MATRIX_OPENCLAW_PRESENTATION_TYPE
-	};
-}
-function resolveMatrixPresentationContent(payload) {
-	const extraContent = asOptionalRecord(resolveMatrixChannelData(payload).extraContent);
-	const presentation = asOptionalRecord(extraContent?.[MATRIX_OPENCLAW_PRESENTATION_KEY]);
-	if (!presentation || presentation.version !== 1 || presentation.type !== MATRIX_OPENCLAW_PRESENTATION_TYPE) return;
-	return presentation;
-}
-function renderMatrixPresentationPayload(params) {
-	const matrixData = resolveMatrixChannelData(params.payload);
-	const fallbackText = renderMessagePresentationFallbackText({
-		text: params.payload.text,
-		presentation: params.presentation,
-		emptyFallback: MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT
-	});
-	return {
-		...params.payload,
-		text: fallbackText,
-		channelData: {
-			...params.payload.channelData,
-			matrix: {
-				...matrixData,
-				extraContent: { [MATRIX_OPENCLAW_PRESENTATION_KEY]: buildMatrixPresentationContent(params.presentation) }
-			}
-		}
-	};
-}
-function prepareMatrixReplyPayload(payload) {
-	return renderPresentationForDelivery({
-		presentationCapabilities: MATRIX_PRESENTATION_CAPABILITIES,
-		renderPresentation: (prepared) => renderMatrixPresentationPayload({
-			payload: prepared,
-			presentation: prepared.presentation
-		})
-	}, payload);
-}
-function resolveMatrixPayloadText(payload) {
-	const text = payload.text ?? "";
-	if (text.trim() || !resolveMatrixPresentationContent(payload)) return text;
-	return MATRIX_EMPTY_PRESENTATION_FALLBACK_TEXT;
-}
-/** Matrix event fields a reply carries beyond its body, currently its presentation. */
-function resolveMatrixExtraContent(payload) {
-	const presentation = resolveMatrixPresentationContent(payload);
-	return presentation ? { [MATRIX_OPENCLAW_PRESENTATION_KEY]: presentation } : void 0;
-}
-function resolveMatrixDeliveryProgress(onDeliveryResult) {
-	return onDeliveryResult ? async (result) => {
-		await onDeliveryResult(attachChannelToResult("matrix", toMatrixOutboundResult(result)));
-	} : void 0;
-}
-const matrixOutbound = {
-	deliveryMode: "direct",
-	chunker: chunkTextForOutbound,
-	chunkerMode: "markdown",
-	textChunkLimit: 4e3,
-	presentationCapabilities: MATRIX_PRESENTATION_CAPABILITIES,
-	renderPresentation: ({ payload, presentation }) => renderMatrixPresentationPayload({
-		payload,
-		presentation
-	}),
-	sendPayload: async ({ cfg, to, payload, mediaLocalRoots, mediaReadFile, mediaAccess, deps, replyToId, replyToIdSource, replyToMode, threadId, accountId, audioAsVoice, deliveryQueueId, signal, assertDirectAdapterHandoff, onPlatformSendDispatch, onDeliveryResult }) => {
-		const send = resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix;
-		const resolvedThreadId = threadId !== void 0 && threadId !== null ? String(threadId) : void 0;
-		const resolveReplyToId = createReplyToFanout({
-			...replyToId != null ? { replyToId } : {},
-			...replyToIdSource !== void 0 ? { replyToIdSource } : {},
-			...replyToMode !== void 0 ? { replyToMode } : {}
-		});
-		const urls = resolveSendableOutboundReplyParts(payload).mediaUrls;
-		const payloadText = resolveMatrixPayloadText(payload);
-		if (urls.length > 0) {
-			const sentResults = [];
-			const lastResult = await sendPayloadMediaSequence({
-				text: payloadText,
-				mediaUrls: urls,
-				send: async ({ text, mediaUrl, index, isFirst }) => await send(to, text, {
-					cfg,
-					mediaUrl,
-					mediaAccess,
-					mediaLocalRoots,
-					mediaReadFile,
-					replyToId: resolveReplyToId(),
-					threadId: resolvedThreadId,
-					accountId: accountId ?? void 0,
-					audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
-					deliveryQueueId,
-					deliveryPartIndex: index,
-					deliveryPartCount: urls.length,
-					signal,
-					assertDirectAdapterHandoff,
-					onPlatformSendDispatch,
-					extraContent: isFirst ? resolveMatrixExtraContent(payload) : void 0,
-					onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-				}),
-				onResult: (result) => {
-					sentResults.push(result);
-				}
-			});
-			if (lastResult !== void 0) {
-				const receipt = createMessageReceiptFromOutboundResults({ results: sentResults });
-				receipt.parts = receipt.parts.map((part, index) => ({
-					...part,
-					index
-				}));
-				return attachChannelToResult("matrix", toMatrixOutboundResult({
-					...lastResult,
-					primaryMessageId: receipt.primaryPlatformMessageId,
-					receipt,
-					content: sentResults.map((result) => result.content).join("\n")
-				}));
-			}
-		}
-		const result = await send(to, payloadText, {
-			cfg,
-			mediaAccess,
-			mediaLocalRoots,
-			mediaReadFile,
-			replyToId: resolveReplyToId(),
-			threadId: resolvedThreadId,
-			accountId: accountId ?? void 0,
-			audioAsVoice: payload.audioAsVoice ?? audioAsVoice,
-			deliveryQueueId,
-			deliveryPartIndex: 0,
-			deliveryPartCount: 1,
-			signal,
-			assertDirectAdapterHandoff,
-			onPlatformSendDispatch,
-			extraContent: resolveMatrixExtraContent(payload),
-			onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-		});
-		return attachChannelToResult("matrix", toMatrixOutboundResult(result));
-	},
-	sendText: async ({ cfg, to, text, deps, replyToId, threadId, accountId, audioAsVoice, deliveryQueueId, deliveryPartIndex, deliveryPartCount, signal, assertDirectAdapterHandoff, onPlatformSendDispatch, onDeliveryResult }) => {
-		const result = await (resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix)(to, text, {
-			cfg,
-			replyToId: replyToId ?? void 0,
-			threadId: threadId !== void 0 && threadId !== null ? String(threadId) : void 0,
-			accountId: accountId ?? void 0,
-			audioAsVoice,
-			deliveryQueueId,
-			deliveryPartIndex,
-			...deliveryQueueId !== void 0 ? { deliveryPartCount } : {},
-			signal,
-			assertDirectAdapterHandoff,
-			onPlatformSendDispatch,
-			onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-		});
-		return attachChannelToResult("matrix", toMatrixOutboundResult(result));
-	},
-	sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, mediaReadFile, mediaAccess, deps, replyToId, threadId, accountId, audioAsVoice, deliveryQueueId, deliveryPartIndex, deliveryPartCount, signal, assertDirectAdapterHandoff, onPlatformSendDispatch, onDeliveryResult }) => {
-		const result = await (resolveOutboundSendDep(deps, "matrix") ?? sendMessageMatrix)(to, text, {
-			cfg,
-			mediaUrl,
-			mediaLocalRoots,
-			mediaReadFile,
-			mediaAccess,
-			replyToId: replyToId ?? void 0,
-			threadId: threadId !== void 0 && threadId !== null ? String(threadId) : void 0,
-			accountId: accountId ?? void 0,
-			audioAsVoice,
-			deliveryQueueId,
-			deliveryPartIndex,
-			...deliveryQueueId !== void 0 ? { deliveryPartCount } : {},
-			signal,
-			assertDirectAdapterHandoff,
-			onPlatformSendDispatch,
-			onDeliveryResult: resolveMatrixDeliveryProgress(onDeliveryResult)
-		});
-		return attachChannelToResult("matrix", toMatrixOutboundResult(result));
-	},
-	sendPoll: async ({ cfg, to, poll, threadId, accountId }) => {
-		const result = await sendPollMatrix(to, poll, {
-			cfg,
-			threadId: threadId !== void 0 && threadId !== null ? threadId : void 0,
-			accountId: accountId ?? void 0
-		});
-		return {
-			channel: "matrix",
-			messageId: result.eventId,
-			roomId: result.roomId,
-			pollId: result.eventId
-		};
-	}
-};
-//#endregion
-export { prepareMatrixReplyPayload as n, resolveMatrixExtraContent as r, matrixOutbound as t };

package/dist/.setup/probe.runtime-qPRZE3Yf.mjs

@@ -1,2 +0,0 @@
-import { n as createMatrixClient } from "./client-DsJUnWlV.mjs";
-export { createMatrixClient };

package/dist/.setup/profile-ClrB3IgR.mjs

@@ -1,108 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-//#region extensions/matrix/src/matrix/profile.ts
-var profile_exports = /* @__PURE__ */ __exportAll({
-	isSupportedMatrixAvatarSource: () => isSupportedMatrixAvatarSource,
-	syncMatrixOwnProfile: () => syncMatrixOwnProfile
-});
-const MATRIX_PROFILE_AVATAR_MAX_BYTES = 10485760;
-function isMatrixMxcUri(value) {
-	return normalizeLowercaseStringOrEmpty(normalizeOptionalString(value)).startsWith("mxc://");
-}
-function isMatrixHttpAvatarUri(value) {
-	const normalized = normalizeLowercaseStringOrEmpty(normalizeOptionalString(value));
-	return normalized.startsWith("https://") || normalized.startsWith("http://");
-}
-function isSupportedMatrixAvatarSource(value) {
-	return isMatrixMxcUri(value) || isMatrixHttpAvatarUri(value);
-}
-async function uploadAvatarMedia(params) {
-	const media = await params.loadAvatar(params.avatarSource, params.avatarMaxBytes);
-	return await params.client.uploadContent(media.buffer, media.contentType, media.fileName || "avatar");
-}
-async function resolveAvatarUrl(params) {
-	const avatarPath = normalizeOptionalString(params.avatarPath) ?? null;
-	if (avatarPath) {
-		if (!params.loadAvatarFromPath) throw new Error("Matrix avatar path upload requires a media loader.");
-		return {
-			resolvedAvatarUrl: await uploadAvatarMedia({
-				client: params.client,
-				avatarSource: avatarPath,
-				avatarMaxBytes: params.avatarMaxBytes,
-				loadAvatar: params.loadAvatarFromPath
-			}),
-			uploadedAvatarSource: "path",
-			convertedAvatarFromHttp: false
-		};
-	}
-	const avatarUrl = normalizeOptionalString(params.avatarUrl) ?? null;
-	if (!avatarUrl) return {
-		resolvedAvatarUrl: null,
-		uploadedAvatarSource: null,
-		convertedAvatarFromHttp: false
-	};
-	if (isMatrixMxcUri(avatarUrl)) return {
-		resolvedAvatarUrl: avatarUrl,
-		uploadedAvatarSource: null,
-		convertedAvatarFromHttp: false
-	};
-	if (!isMatrixHttpAvatarUri(avatarUrl)) throw new Error("Matrix avatar URL must be an mxc:// URI or an http(s) URL.");
-	if (!params.loadAvatarFromUrl) throw new Error("Matrix avatar URL conversion requires a media loader.");
-	return {
-		resolvedAvatarUrl: await uploadAvatarMedia({
-			client: params.client,
-			avatarSource: avatarUrl,
-			avatarMaxBytes: params.avatarMaxBytes,
-			loadAvatar: params.loadAvatarFromUrl
-		}),
-		uploadedAvatarSource: "http",
-		convertedAvatarFromHttp: true
-	};
-}
-async function syncMatrixOwnProfile(params) {
-	const desiredDisplayName = normalizeOptionalString(params.displayName) ?? null;
-	const avatar = await resolveAvatarUrl({
-		client: params.client,
-		avatarUrl: params.avatarUrl ?? null,
-		avatarPath: params.avatarPath ?? null,
-		avatarMaxBytes: params.avatarMaxBytes ?? MATRIX_PROFILE_AVATAR_MAX_BYTES,
-		loadAvatarFromUrl: params.loadAvatarFromUrl,
-		loadAvatarFromPath: params.loadAvatarFromPath
-	});
-	const desiredAvatarUrl = avatar.resolvedAvatarUrl;
-	if (!desiredDisplayName && !desiredAvatarUrl) return {
-		skipped: true,
-		displayNameUpdated: false,
-		avatarUpdated: false,
-		resolvedAvatarUrl: null,
-		uploadedAvatarSource: avatar.uploadedAvatarSource,
-		convertedAvatarFromHttp: avatar.convertedAvatarFromHttp
-	};
-	let currentDisplayName;
-	let currentAvatarUrl;
-	try {
-		const currentProfile = await params.client.getUserProfile(params.userId);
-		currentDisplayName = normalizeOptionalString(currentProfile.displayname);
-		currentAvatarUrl = normalizeOptionalString(currentProfile.avatar_url);
-	} catch {}
-	let displayNameUpdated = false;
-	let avatarUpdated = false;
-	if (desiredDisplayName && currentDisplayName !== desiredDisplayName) {
-		await params.client.setDisplayName(desiredDisplayName);
-		displayNameUpdated = true;
-	}
-	if (desiredAvatarUrl && currentAvatarUrl !== desiredAvatarUrl) {
-		await params.client.setAvatarUrl(desiredAvatarUrl);
-		avatarUpdated = true;
-	}
-	return {
-		skipped: false,
-		displayNameUpdated,
-		avatarUpdated,
-		resolvedAvatarUrl: desiredAvatarUrl,
-		uploadedAvatarSource: avatar.uploadedAvatarSource,
-		convertedAvatarFromHttp: avatar.convertedAvatarFromHttp
-	};
-}
-//#endregion
-export { profile_exports as n, syncMatrixOwnProfile as r, isSupportedMatrixAvatarSource as t };

package/dist/.setup/profile-update-DPttQz3-.mjs

@@ -1,70 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { n as resolveMatrixConfigPath, r as updateMatrixAccountConfig } from "./config-update-B_4qZ5bV.mjs";
-import { r as syncMatrixOwnProfile } from "./profile-ClrB3IgR.mjs";
-import { n as withResolvedActionClient } from "./client-By2B3Wz4.mjs";
-import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
-//#region extensions/matrix/src/matrix/actions/profile.ts
-async function updateMatrixOwnProfile(opts = {}) {
-	const displayName = opts.displayName?.trim();
-	const avatarUrl = opts.avatarUrl?.trim();
-	const avatarPath = opts.avatarPath?.trim();
-	const runtime = getMatrixRuntime();
-	return await withResolvedActionClient(opts, async (client) => {
-		const userId = await client.getUserId();
-		return await syncMatrixOwnProfile({
-			client,
-			userId,
-			displayName: displayName || void 0,
-			avatarUrl: avatarUrl || void 0,
-			avatarPath: avatarPath || void 0,
-			loadAvatarFromUrl: async (url, maxBytes) => await runtime.media.loadWebMedia(url, maxBytes),
-			loadAvatarFromPath: async (path, maxBytes) => await runtime.media.loadWebMedia(path, {
-				maxBytes,
-				localRoots: opts.mediaLocalRoots
-			})
-		});
-	}, "persist");
-}
-//#endregion
-//#region extensions/matrix/src/profile-update.ts
-async function applyMatrixProfileUpdate(params) {
-	const runtime = getMatrixRuntime();
-	const persistedCfg = runtime.config.current();
-	const accountId = normalizeAccountId(params.account);
-	const displayName = params.displayName?.trim() || null;
-	const avatarUrl = params.avatarUrl?.trim() || null;
-	const avatarPath = params.avatarPath?.trim() || null;
-	if (!displayName && !avatarUrl && !avatarPath) throw new Error("Provide name/displayName and/or avatarUrl/avatarPath.");
-	const synced = await updateMatrixOwnProfile({
-		cfg: params.cfg,
-		accountId,
-		displayName: displayName ?? void 0,
-		avatarUrl: avatarUrl ?? void 0,
-		avatarPath: avatarPath ?? void 0,
-		mediaLocalRoots: params.mediaLocalRoots
-	});
-	const persistedAvatarUrl = synced.uploadedAvatarSource && synced.resolvedAvatarUrl ? synced.resolvedAvatarUrl : avatarUrl;
-	const updated = updateMatrixAccountConfig(persistedCfg, accountId, {
-		name: displayName ?? void 0,
-		avatarUrl: persistedAvatarUrl ?? void 0
-	});
-	await runtime.config.replaceConfigFile({
-		nextConfig: updated,
-		afterWrite: { mode: "auto" }
-	});
-	return {
-		accountId,
-		displayName,
-		avatarUrl: persistedAvatarUrl ?? null,
-		profile: {
-			displayNameUpdated: synced.displayNameUpdated,
-			avatarUpdated: synced.avatarUpdated,
-			resolvedAvatarUrl: synced.resolvedAvatarUrl,
-			uploadedAvatarSource: synced.uploadedAvatarSource,
-			convertedAvatarFromHttp: synced.convertedAvatarFromHttp
-		},
-		configPath: resolveMatrixConfigPath(updated, accountId)
-	};
-}
-//#endregion
-export { updateMatrixOwnProfile as n, applyMatrixProfileUpdate as t };

package/dist/.setup/reaction-events-CdAk_rh_.mjs

@@ -1,167 +0,0 @@
-import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
-import { i as resolveMatrixThreadRouting, r as resolveMatrixInboundRoute } from "./channel-q6TBKEiG.mjs";
-import { c as extractMatrixReactionAnnotation } from "./send-currentness-BrGXL7b8.mjs";
-import { p as resolveMatrixThreadRootId } from "./direct-management-B2Bno2xL.mjs";
-import { i as resolveMatrixApprovalReactionTargetWithPersistence, o as unregisterMatrixApprovalReactionTargetsForApproval } from "./approval-reactions-B0hfA6qz.mjs";
-import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
-import { isApprovalNotFoundError } from "openclaw/plugin-sdk/error-runtime";
-import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import { getSessionBindingService } from "openclaw/plugin-sdk/session-binding-runtime";
-//#region extensions/matrix/src/matrix/monitor/reaction-events.ts
-const loadApprovalReactionAuth = createLazyRuntimeModule(() => import("./approval-reaction-auth-B51E4ZDa.mjs"));
-const loadExecApprovalResolver = createLazyRuntimeModule(() => import("openclaw/plugin-sdk/approval-gateway-runtime"));
-const loadMatrixSend = createLazyRuntimeModule(() => import("./send-h0gZ_-qk.mjs").then((n) => n.s));
-function buildMatrixApprovalTerminalText(result) {
-	const approval = result.approval;
-	const terminalLabel = approval.status === "allowed" ? approval.decision === "allow-always" ? "Allowed always" : "Allowed once" : approval.status === "denied" ? "Denied" : approval.status === "expired" ? "Expired" : "Cancelled";
-	return `${result.applied ? "Resolved" : "Already resolved"}: ${terminalLabel}\n\nID: ${approval.id}`;
-}
-async function retireMatrixApprovalReactionTargets(params) {
-	const accountId = normalizeAccountId(params.accountId);
-	const registeredTargets = await unregisterMatrixApprovalReactionTargetsForApproval({
-		accountId,
-		approvalId: params.approvalId,
-		approvalKind: params.approvalKind
-	});
-	const targets = /* @__PURE__ */ new Map();
-	for (const target of [...registeredTargets, {
-		accountId,
-		roomId: params.roomId,
-		eventId: params.targetEventId
-	}]) targets.set(JSON.stringify([
-		target.accountId,
-		target.roomId,
-		target.eventId
-	]), target);
-	const { editMessageMatrix } = await loadMatrixSend();
-	const terminalText = buildMatrixApprovalTerminalText(params.result);
-	const failedUpdates = (await Promise.allSettled(Array.from(targets.values(), async (target) => {
-		await editMessageMatrix(target.roomId, target.eventId, terminalText, {
-			cfg: params.cfg,
-			accountId: target.accountId,
-			client: params.client
-		});
-	}))).filter((update) => update.status === "rejected").length;
-	if (failedUpdates > 0) params.logVerboseMessage(`matrix: failed to terminalize ${failedUpdates} approval prompt(s) id=${params.approvalId}`);
-}
-function resolveMatrixReactionNotificationMode(params) {
-	const matrixConfig = params.cfg.channels?.matrix;
-	return resolveMatrixAccountConfig({
-		cfg: params.cfg,
-		accountId: params.accountId
-	}).reactionNotifications ?? matrixConfig?.reactionNotifications ?? "own";
-}
-async function maybeResolveMatrixApprovalReaction(params) {
-	if (!params.target) return false;
-	const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
-	if (!isMatrixApprovalReactionAuthorizedSender({
-		...params,
-		approvalKind: params.target.approvalKind
-	})) return false;
-	const { resolveApprovalOverGateway } = await loadExecApprovalResolver();
-	try {
-		const result = await resolveApprovalOverGateway({
-			cfg: params.cfg,
-			approvalId: params.target.approvalId,
-			approvalKind: params.target.approvalKind,
-			decision: params.target.decision,
-			channel: "matrix",
-			accountId: params.accountId,
-			senderId: params.senderId
-		});
-		await retireMatrixApprovalReactionTargets({
-			cfg: params.cfg,
-			accountId: params.accountId,
-			client: params.client,
-			roomId: params.roomId,
-			targetEventId: params.targetEventId,
-			approvalId: params.target.approvalId,
-			approvalKind: params.target.approvalKind,
-			result,
-			logVerboseMessage: params.logVerboseMessage
-		});
-		const canonicalDecision = "decision" in result.approval ? result.approval.decision : "none";
-		params.logVerboseMessage(`matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} applied=${result.applied} status=${result.approval.status} decision=${canonicalDecision}`);
-		return true;
-	} catch (err) {
-		if (isApprovalNotFoundError(err)) {
-			await unregisterMatrixApprovalReactionTargetsForApproval({
-				accountId: params.accountId,
-				approvalId: params.target.approvalId,
-				approvalKind: params.target.approvalKind
-			});
-			params.logVerboseMessage(`matrix: approval reaction ignored for expired approval id=${params.target.approvalId} sender=${params.senderId}`);
-			return true;
-		}
-		params.logVerboseMessage(`matrix: approval reaction failed id=${params.target.approvalId} sender=${params.senderId}: ${String(err)}`);
-		throw err;
-	}
-}
-async function handleInboundMatrixReaction(params) {
-	const reaction = extractMatrixReactionAnnotation(params.event.content);
-	if (!reaction?.eventId) return;
-	if (params.senderId === params.selfUserId) return;
-	const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
-		accountId: params.accountId,
-		roomId: params.roomId,
-		eventId: reaction.eventId,
-		reactionKey: reaction.key
-	});
-	if (await maybeResolveMatrixApprovalReaction({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		senderId: params.senderId,
-		target: approvalTarget,
-		targetEventId: reaction.eventId,
-		roomId: params.roomId,
-		client: params.client,
-		logVerboseMessage: params.logVerboseMessage
-	})) return;
-	const notificationMode = resolveMatrixReactionNotificationMode({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	if (notificationMode === "off") return;
-	const targetEvent = await params.client.getEvent(params.roomId, reaction.eventId).catch((err) => {
-		params.logVerboseMessage(`matrix: failed resolving reaction target room=${params.roomId} id=${reaction.eventId}: ${String(err)}`);
-		return null;
-	});
-	const targetSender = targetEvent && typeof targetEvent.sender === "string" ? targetEvent.sender.trim() : "";
-	if (!targetSender) return;
-	if (notificationMode === "own" && targetSender !== params.selfUserId) return;
-	const targetContent = targetEvent && targetEvent.content && typeof targetEvent.content === "object" ? targetEvent.content : void 0;
-	const threadRootId = targetContent ? resolveMatrixThreadRootId(targetContent) : void 0;
-	const accountConfig = resolveMatrixAccountConfig({
-		cfg: params.cfg,
-		accountId: params.accountId
-	});
-	const thread = resolveMatrixThreadRouting({
-		isDirectMessage: params.isDirectMessage,
-		threadReplies: accountConfig.threadReplies ?? "inbound",
-		dmThreadReplies: accountConfig.dm?.threadReplies,
-		messageId: reaction.eventId,
-		threadRootId
-	});
-	const { route, runtimeBindingId } = resolveMatrixInboundRoute({
-		cfg: params.cfg,
-		accountId: params.accountId,
-		roomId: params.roomId,
-		senderId: params.senderId,
-		isDirectMessage: params.isDirectMessage,
-		dmSessionScope: accountConfig.dm?.sessionScope ?? "per-user",
-		threadId: thread.threadId,
-		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
-	});
-	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts, {
-		channel: "matrix",
-		accountId: params.accountId
-	});
-	const text = `Matrix reaction added: ${reaction.key} by ${params.senderLabel} on msg ${reaction.eventId}`;
-	params.core.system.enqueueSystemEvent(text, {
-		sessionKey: route.sessionKey,
-		contextKey: `matrix:reaction:add:${params.roomId}:${reaction.eventId}:${params.senderId}:${reaction.key}`
-	});
-	params.logVerboseMessage(`matrix: reaction event enqueued room=${params.roomId} target=${reaction.eventId} sender=${params.senderId} emoji=${reaction.key}`);
-}
-//#endregion
-export { handleInboundMatrixReaction };