@kodelyth/matrix 2026.5.39 → 2026.6.1

package/dist/plugin-entry.handlers.runtime.js

@@ -0,0 +1,51 @@
+import { t as formatMatrixErrorMessage } from "./errors-BETj3zr9.js";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/plugin-entry.runtime.ts
+let matrixVerificationRuntimePromise;
+function loadMatrixVerificationRuntime() {
+	matrixVerificationRuntimePromise ??= import("./verification-7tDPRpJU.js").then((n) => n.y);
+	return matrixVerificationRuntimePromise;
+}
+function sendError(respond, err) {
+	respond(false, { error: formatMatrixErrorMessage(err) });
+}
+async function handleVerifyRecoveryKey({ params, respond }) {
+	try {
+		const { verifyMatrixRecoveryKey } = await loadMatrixVerificationRuntime();
+		const key = normalizeOptionalString(params?.key);
+		if (!key) {
+			respond(false, { error: "key required" });
+			return;
+		}
+		const result = await verifyMatrixRecoveryKey(key, { accountId: normalizeOptionalString(params?.accountId) });
+		respond(result.success, result);
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+async function handleVerificationBootstrap({ params, respond }) {
+	try {
+		const { bootstrapMatrixVerification } = await loadMatrixVerificationRuntime();
+		const result = await bootstrapMatrixVerification({
+			accountId: normalizeOptionalString(params?.accountId),
+			recoveryKey: typeof params?.recoveryKey === "string" ? params.recoveryKey : void 0,
+			forceResetCrossSigning: params?.forceResetCrossSigning === true
+		});
+		respond(result.success, result);
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+async function handleVerificationStatus({ params, respond }) {
+	try {
+		const { getMatrixVerificationStatus } = await loadMatrixVerificationRuntime();
+		respond(true, await getMatrixVerificationStatus({
+			accountId: normalizeOptionalString(params?.accountId),
+			includeRecoveryKey: params?.includeRecoveryKey === true
+		}));
+	} catch (err) {
+		sendError(respond, err);
+	}
+}
+//#endregion
+export { handleVerificationBootstrap, handleVerificationStatus, handleVerifyRecoveryKey };

package/dist/probe.runtime-CjJS53Kz.js

@@ -0,0 +1,3 @@
+import { t as createMatrixClient } from "./create-client-J0htTaRj.js";
+import "./client-PhrTwuC4.js";
+export { createMatrixClient };

package/dist/profile-update-DqkPgZ1P.js

@@ -0,0 +1,68 @@
+import { t as getMatrixRuntime } from "./runtime-B-Fyrmxo.js";
+import { c as resolveMatrixConfigPath, l as updateMatrixAccountConfig, o as syncMatrixOwnProfile } from "./setup-core-BEYoXF3J.js";
+import { n as withResolvedActionClient } from "./client-BnohYygh.js";
+import { normalizeAccountId } from "klaw/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) => {
+		return await syncMatrixOwnProfile({
+			client,
+			userId: await client.getUserId(),
+			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/reaction-common-CmVLzP-u.js

@@ -0,0 +1,71 @@
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/matrix/reaction-common.ts
+const MATRIX_ANNOTATION_RELATION_TYPE = "m.annotation";
+const MATRIX_REACTION_EVENT_TYPE = "m.reaction";
+function normalizeMatrixReactionMessageId(messageId) {
+	const normalized = messageId.trim();
+	if (!normalized) throw new Error("Matrix reaction requires a messageId");
+	return normalized;
+}
+function normalizeMatrixReactionEmoji(emoji) {
+	const normalized = emoji.trim();
+	if (!normalized) throw new Error("Matrix reaction requires an emoji");
+	return normalized;
+}
+function buildMatrixReactionContent(messageId, emoji) {
+	return { "m.relates_to": {
+		rel_type: MATRIX_ANNOTATION_RELATION_TYPE,
+		event_id: normalizeMatrixReactionMessageId(messageId),
+		key: normalizeMatrixReactionEmoji(emoji)
+	} };
+}
+function buildMatrixReactionRelationsPath(roomId, messageId) {
+	return `/_matrix/client/v1/rooms/${encodeURIComponent(roomId)}/relations/${encodeURIComponent(normalizeMatrixReactionMessageId(messageId))}/${MATRIX_ANNOTATION_RELATION_TYPE}/${MATRIX_REACTION_EVENT_TYPE}`;
+}
+function extractMatrixReactionAnnotation(content) {
+	if (!content || typeof content !== "object") return;
+	const relatesTo = content["m.relates_to"];
+	if (!relatesTo || typeof relatesTo !== "object") return;
+	if (typeof relatesTo.rel_type === "string" && relatesTo.rel_type !== "m.annotation") return;
+	const key = normalizeOptionalString(relatesTo.key) ?? "";
+	if (!key) return;
+	return {
+		key,
+		eventId: (normalizeOptionalString(relatesTo.event_id) ?? "") || void 0
+	};
+}
+function extractMatrixReactionKey(content) {
+	return extractMatrixReactionAnnotation(content)?.key;
+}
+function summarizeMatrixReactionEvents(events) {
+	const summaries = /* @__PURE__ */ new Map();
+	for (const event of events) {
+		const key = extractMatrixReactionKey(event.content);
+		if (!key) continue;
+		const sender = normalizeOptionalString(event.sender) ?? "";
+		const entry = summaries.get(key) ?? {
+			key,
+			count: 0,
+			users: []
+		};
+		entry.count += 1;
+		if (sender && !entry.users.includes(sender)) entry.users.push(sender);
+		summaries.set(key, entry);
+	}
+	return Array.from(summaries.values());
+}
+function selectOwnMatrixReactionEventIds(events, userId, emoji) {
+	const senderId = normalizeOptionalString(userId) ?? "";
+	if (!senderId) return [];
+	const targetEmoji = normalizeOptionalString(emoji);
+	const ids = [];
+	for (const event of events) {
+		if ((normalizeOptionalString(event.sender) ?? "") !== senderId) continue;
+		if (targetEmoji && extractMatrixReactionKey(event.content) !== targetEmoji) continue;
+		const eventId = normalizeOptionalString(event.event_id);
+		if (eventId) ids.push(eventId);
+	}
+	return ids;
+}
+//#endregion
+export { extractMatrixReactionAnnotation as a, buildMatrixReactionRelationsPath as i, MATRIX_REACTION_EVENT_TYPE as n, selectOwnMatrixReactionEventIds as o, buildMatrixReactionContent as r, summarizeMatrixReactionEvents as s, MATRIX_ANNOTATION_RELATION_TYPE as t };

package/dist/reaction-events-D0nUJuZV.js

@@ -0,0 +1,121 @@
+import { c as resolveMatrixAccountConfig } from "./config-paths-DVvt6vM3.js";
+import { a as extractMatrixReactionAnnotation } from "./reaction-common-CmVLzP-u.js";
+import { a as unregisterMatrixApprovalReactionTarget, i as resolveMatrixApprovalReactionTargetWithPersistence } from "./approval-reactions-nDm2x-K5.js";
+import { i as resolveMatrixThreadRouting, r as resolveMatrixThreadRootId, t as resolveMatrixInboundRoute } from "./route-xRKj_ESW.js";
+import { getSessionBindingService } from "klaw/plugin-sdk/session-binding-runtime";
+//#region extensions/matrix/src/matrix/monitor/reaction-events.ts
+let approvalReactionAuthPromise;
+let execApprovalResolverPromise;
+function loadApprovalReactionAuth() {
+	approvalReactionAuthPromise ??= import("./approval-reaction-auth-CL0-nCNV.js");
+	return approvalReactionAuthPromise;
+}
+function loadExecApprovalResolver() {
+	execApprovalResolverPromise ??= import("./exec-approval-resolver-BxPorU_t.js");
+	return execApprovalResolverPromise;
+}
+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 approvalKind = params.target.approvalId.startsWith("plugin:") ? "plugin" : "exec";
+	const { isMatrixApprovalReactionAuthorizedSender } = await loadApprovalReactionAuth();
+	if (!isMatrixApprovalReactionAuthorizedSender({
+		...params,
+		approvalKind
+	})) return false;
+	const { isApprovalNotFoundError, resolveMatrixApproval } = await loadExecApprovalResolver();
+	try {
+		await resolveMatrixApproval({
+			cfg: params.cfg,
+			approvalId: params.target.approvalId,
+			decision: params.target.decision,
+			senderId: params.senderId
+		});
+		params.logVerboseMessage(`matrix: approval reaction resolved id=${params.target.approvalId} sender=${params.senderId} decision=${params.target.decision}`);
+		return true;
+	} catch (err) {
+		if (isApprovalNotFoundError(err)) {
+			unregisterMatrixApprovalReactionTarget({
+				roomId: params.roomId,
+				eventId: params.targetEventId
+			});
+			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)}`);
+		return true;
+	}
+}
+async function handleInboundMatrixReaction(params) {
+	const reaction = extractMatrixReactionAnnotation(params.event.content);
+	if (!reaction?.eventId) return;
+	if (params.senderId === params.selfUserId) return;
+	const approvalTarget = await resolveMatrixApprovalReactionTargetWithPersistence({
+		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,
+		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({
+		event: targetEvent,
+		content: 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,
+		eventTs: params.event.origin_server_ts,
+		resolveAgentRoute: params.core.channel.routing.resolveAgentRoute
+	});
+	if (runtimeBindingId) getSessionBindingService().touch(runtimeBindingId, params.event.origin_server_ts);
+	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, resolveMatrixReactionNotificationMode };

package/dist/record-shared-DGvSFn5M.js

@@ -0,0 +1,2 @@
+import { isRecord } from "klaw/plugin-sdk/string-coerce-runtime";
+export { isRecord as t };

package/dist/resolve-targets-ChECUzD2.js

@@ -0,0 +1,140 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Bsazo8si.js";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-i3T8uORc.js";
+import { normalizeOptionalLowercaseString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/resolve-targets.ts
+var resolve_targets_exports = /* @__PURE__ */ __exportAll({ resolveMatrixTargets: () => resolveMatrixTargets });
+function normalizeLookupQuery(query) {
+	return normalizeOptionalLowercaseString(query) ?? "";
+}
+function findExactDirectoryMatches(matches, query) {
+	const normalized = normalizeLookupQuery(query);
+	if (!normalized) return [];
+	return matches.filter((match) => {
+		const id = normalizeOptionalLowercaseString(match.id);
+		const name = normalizeOptionalLowercaseString(match.name);
+		const handle = normalizeOptionalLowercaseString(match.handle);
+		return normalized === id || normalized === name || normalized === handle;
+	});
+}
+function pickBestGroupMatch(matches, query) {
+	if (matches.length === 0) return {};
+	const exact = findExactDirectoryMatches(matches, query);
+	if (exact.length > 1) return {
+		best: exact[0],
+		note: "multiple exact matches; chose first"
+	};
+	if (exact.length === 1) return { best: exact[0] };
+	return {
+		best: matches[0],
+		note: matches.length > 1 ? "multiple matches; chose first" : void 0
+	};
+}
+function pickBestUserMatch(matches, query) {
+	if (matches.length === 0) return;
+	const exact = findExactDirectoryMatches(matches, query);
+	if (exact.length === 1) return exact[0];
+}
+function describeUserMatchFailure(matches, query) {
+	if (matches.length === 0) return "no matches";
+	const normalized = normalizeLookupQuery(query);
+	if (!normalized) return "empty input";
+	const exact = findExactDirectoryMatches(matches, normalized);
+	if (exact.length === 0) return "no exact match; use full Matrix ID";
+	if (exact.length > 1) return "multiple exact matches; use full Matrix ID";
+	return "no exact match; use full Matrix ID";
+}
+async function readCachedMatches(cache, query, lookup) {
+	const key = normalizeLookupQuery(query);
+	if (!key) return [];
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const matches = await lookup(query.trim());
+	cache.set(key, matches);
+	return matches;
+}
+async function resolveMatrixTargets(params) {
+	const results = [];
+	const userLookupCache = /* @__PURE__ */ new Map();
+	const groupLookupCache = /* @__PURE__ */ new Map();
+	for (const input of params.inputs) {
+		const trimmed = input.trim();
+		if (!trimmed) {
+			results.push({
+				input,
+				resolved: false,
+				note: "empty input"
+			});
+			continue;
+		}
+		if (params.kind === "user") {
+			const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
+			if (normalizedTarget && isMatrixQualifiedUserId(normalizedTarget)) {
+				results.push({
+					input,
+					resolved: true,
+					id: normalizedTarget
+				});
+				continue;
+			}
+			try {
+				const matches = await readCachedMatches(userLookupCache, trimmed, (query) => listMatrixDirectoryPeersLive({
+					cfg: params.cfg,
+					accountId: params.accountId,
+					query,
+					limit: 5
+				}));
+				const best = pickBestUserMatch(matches, trimmed);
+				results.push({
+					input,
+					resolved: Boolean(best?.id),
+					id: best?.id,
+					name: best?.name,
+					note: best ? void 0 : describeUserMatchFailure(matches, trimmed)
+				});
+			} catch (err) {
+				params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+				results.push({
+					input,
+					resolved: false,
+					note: "lookup failed"
+				});
+			}
+			continue;
+		}
+		const normalizedTarget = normalizeMatrixMessagingTarget(trimmed);
+		if (normalizedTarget?.startsWith("!")) {
+			results.push({
+				input,
+				resolved: true,
+				id: normalizedTarget
+			});
+			continue;
+		}
+		try {
+			const { best, note } = pickBestGroupMatch(await readCachedMatches(groupLookupCache, trimmed, (query) => listMatrixDirectoryGroupsLive({
+				cfg: params.cfg,
+				accountId: params.accountId,
+				query,
+				limit: 5
+			})), trimmed);
+			results.push({
+				input,
+				resolved: Boolean(best?.id),
+				id: best?.id,
+				name: best?.name,
+				note
+			});
+		} catch (err) {
+			params.runtime?.error?.(`matrix resolve failed: ${String(err)}`);
+			results.push({
+				input,
+				resolved: false,
+				note: "lookup failed"
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+export { resolve_targets_exports as n, resolveMatrixTargets as t };

package/dist/resolver.runtime-hdY3n0GO.js

@@ -0,0 +1,5 @@
+import { t as resolveMatrixTargets } from "./resolve-targets-ChECUzD2.js";
+//#region extensions/matrix/src/resolver.runtime.ts
+const matrixResolverRuntime = { resolveMatrixTargets };
+//#endregion
+export { matrixResolverRuntime };

package/dist/rolldown-runtime-DUslC3ob.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/route-xRKj_ESW.js

@@ -0,0 +1,161 @@
+import { n as MATRIX_REACTION_EVENT_TYPE } from "./reaction-common-CmVLzP-u.js";
+import { buildAgentSessionKey, deriveLastRoutePolicy, resolveAgentIdFromSessionKey, resolveThreadSessionKeys } from "klaw/plugin-sdk/routing";
+import { resolveConfiguredAcpBindingRecord } from "klaw/plugin-sdk/acp-binding-resolve-runtime";
+import { getSessionBindingService } from "klaw/plugin-sdk/session-binding-runtime";
+//#region extensions/matrix/src/matrix/monitor/types.ts
+const EventType = {
+	RoomMessage: "m.room.message",
+	RoomMessageEncrypted: "m.room.encrypted",
+	RoomMember: "m.room.member",
+	Location: "m.location",
+	Reaction: MATRIX_REACTION_EVENT_TYPE
+};
+const RelationType = {
+	Replace: "m.replace",
+	Thread: "m.thread"
+};
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/threads.ts
+function resolveMatrixThreadSessionKeys(params) {
+	return resolveThreadSessionKeys({
+		...params,
+		normalizeThreadId: (threadId) => threadId
+	});
+}
+function resolveMatrixRelatedReplyToEventId(relates) {
+	if (!relates || typeof relates !== "object") return;
+	if ("m.in_reply_to" in relates && typeof relates["m.in_reply_to"] === "object" && relates["m.in_reply_to"] && "event_id" in relates["m.in_reply_to"] && typeof relates["m.in_reply_to"].event_id === "string") return relates["m.in_reply_to"].event_id;
+}
+function resolveMatrixThreadRouting(params) {
+	const effectiveThreadReplies = params.isDirectMessage && params.dmThreadReplies !== void 0 ? params.dmThreadReplies : params.threadReplies;
+	const messageId = params.messageId.trim();
+	const threadRootId = params.threadRootId?.trim();
+	const inboundThreadId = threadRootId && threadRootId !== messageId ? threadRootId : void 0;
+	return { threadId: effectiveThreadReplies === "off" ? void 0 : effectiveThreadReplies === "inbound" ? inboundThreadId : inboundThreadId ?? (messageId || void 0) };
+}
+function resolveMatrixThreadRootId(params) {
+	const relates = params.content["m.relates_to"];
+	if (!relates || typeof relates !== "object") return;
+	if ("rel_type" in relates && relates.rel_type === RelationType.Thread) {
+		if ("event_id" in relates && typeof relates.event_id === "string") return relates.event_id;
+		return resolveMatrixRelatedReplyToEventId(relates);
+	}
+}
+function resolveMatrixReplyToEventId(content) {
+	return resolveMatrixRelatedReplyToEventId(content["m.relates_to"]);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/monitor/route.ts
+function resolveMatrixDmSessionKey(params) {
+	if (params.dmSessionScope !== "per-room") return params.fallbackSessionKey;
+	return buildAgentSessionKey({
+		agentId: params.agentId,
+		channel: "matrix",
+		accountId: params.accountId,
+		peer: {
+			kind: "channel",
+			id: params.roomId
+		}
+	});
+}
+function shouldApplyMatrixPerRoomDmSessionScope(params) {
+	return params.isDirectMessage && !params.configuredSessionKey;
+}
+function resolveMatrixInboundRoute(params) {
+	const baseRoute = params.resolveAgentRoute({
+		cfg: params.cfg,
+		channel: "matrix",
+		accountId: params.accountId,
+		peer: {
+			kind: params.isDirectMessage ? "direct" : "channel",
+			id: params.isDirectMessage ? params.senderId : params.roomId
+		},
+		parentPeer: params.isDirectMessage ? {
+			kind: "channel",
+			id: params.roomId
+		} : void 0
+	});
+	const bindingConversationId = params.threadId ?? params.roomId;
+	const bindingParentConversationId = params.threadId ? params.roomId : void 0;
+	const runtimeBinding = getSessionBindingService().resolveByConversation({
+		channel: "matrix",
+		accountId: params.accountId,
+		conversationId: bindingConversationId,
+		parentConversationId: bindingParentConversationId
+	});
+	const boundSessionKey = runtimeBinding?.targetSessionKey?.trim();
+	if (runtimeBinding && boundSessionKey) return {
+		route: {
+			...baseRoute,
+			sessionKey: boundSessionKey,
+			agentId: resolveAgentIdFromSessionKey(boundSessionKey) || baseRoute.agentId,
+			lastRoutePolicy: deriveLastRoutePolicy({
+				sessionKey: boundSessionKey,
+				mainSessionKey: baseRoute.mainSessionKey
+			}),
+			matchedBy: "binding.channel"
+		},
+		configuredBinding: null,
+		runtimeBindingId: runtimeBinding.bindingId
+	};
+	const configuredBinding = runtimeBinding == null ? resolveConfiguredAcpBindingRecord({
+		cfg: params.cfg,
+		channel: "matrix",
+		accountId: params.accountId,
+		conversationId: bindingConversationId,
+		parentConversationId: bindingParentConversationId
+	}) : null;
+	const configuredSessionKey = configuredBinding?.record.targetSessionKey?.trim();
+	const effectiveRoute = configuredBinding && configuredSessionKey ? {
+		...baseRoute,
+		sessionKey: configuredSessionKey,
+		agentId: resolveAgentIdFromSessionKey(configuredSessionKey) || configuredBinding.spec.agentId || baseRoute.agentId,
+		lastRoutePolicy: deriveLastRoutePolicy({
+			sessionKey: configuredSessionKey,
+			mainSessionKey: baseRoute.mainSessionKey
+		}),
+		matchedBy: "binding.channel"
+	} : baseRoute;
+	const dmSessionKey = shouldApplyMatrixPerRoomDmSessionScope({
+		isDirectMessage: params.isDirectMessage,
+		configuredSessionKey
+	}) ? resolveMatrixDmSessionKey({
+		accountId: params.accountId,
+		agentId: effectiveRoute.agentId,
+		roomId: params.roomId,
+		dmSessionScope: params.dmSessionScope,
+		fallbackSessionKey: effectiveRoute.sessionKey
+	}) : effectiveRoute.sessionKey;
+	const routeWithDmScope = dmSessionKey === effectiveRoute.sessionKey ? effectiveRoute : {
+		...effectiveRoute,
+		sessionKey: dmSessionKey,
+		lastRoutePolicy: "session"
+	};
+	if (!configuredBinding && !configuredSessionKey && params.threadId) {
+		const threadKeys = resolveMatrixThreadSessionKeys({
+			baseSessionKey: routeWithDmScope.sessionKey,
+			threadId: params.threadId,
+			parentSessionKey: routeWithDmScope.sessionKey
+		});
+		return {
+			route: {
+				...routeWithDmScope,
+				sessionKey: threadKeys.sessionKey,
+				mainSessionKey: threadKeys.parentSessionKey ?? routeWithDmScope.sessionKey,
+				lastRoutePolicy: deriveLastRoutePolicy({
+					sessionKey: threadKeys.sessionKey,
+					mainSessionKey: threadKeys.parentSessionKey ?? routeWithDmScope.sessionKey
+				})
+			},
+			configuredBinding,
+			runtimeBindingId: null
+		};
+	}
+	return {
+		route: routeWithDmScope,
+		configuredBinding,
+		runtimeBindingId: null
+	};
+}
+//#endregion
+export { EventType as a, resolveMatrixThreadRouting as i, resolveMatrixReplyToEventId as n, RelationType as o, resolveMatrixThreadRootId as r, resolveMatrixInboundRoute as t };

package/dist/runtime-B-Fyrmxo.js

@@ -0,0 +1,8 @@
+import { createPluginRuntimeStore } from "klaw/plugin-sdk/runtime-store";
+//#region extensions/matrix/src/runtime.ts
+const { setRuntime: setMatrixRuntime, getRuntime: getMatrixRuntime, tryGetRuntime: getOptionalMatrixRuntime } = createPluginRuntimeStore({
+	pluginId: "matrix",
+	errorMessage: "Matrix runtime not initialized"
+});
+//#endregion
+export { getOptionalMatrixRuntime as n, setMatrixRuntime as r, getMatrixRuntime as t };

package/dist/runtime-api-BYXXkxq2.js

@@ -0,0 +1,24 @@
+import "./timeout-abort-signal-DpSHDHhR.js";
+import "klaw/plugin-sdk/account-id";
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel } from "klaw/plugin-sdk/conversation-runtime";
+import "klaw/plugin-sdk/channel-message";
+import { chunkTextForOutbound as chunkTextForOutbound$1 } from "klaw/plugin-sdk/text-chunking";
+import { createActionGate as createActionGate$1, jsonResult, readNumberParam as readNumberParam$1, readReactionParams, readStringArrayParam, readStringParam as readStringParam$1 } from "klaw/plugin-sdk/channel-actions";
+import "klaw/plugin-sdk/routing";
+import "klaw/plugin-sdk/channel-status";
+import "klaw/plugin-sdk/channel-config-primitives";
+import "klaw/plugin-sdk/ssrf-runtime";
+import "klaw/plugin-sdk/channel-location";
+import "klaw/plugin-sdk/channel-logging";
+import "klaw/plugin-sdk/channel-targets";
+import "klaw/plugin-sdk/setup";
+import "klaw/plugin-sdk/json-store";
+import "klaw/plugin-sdk/outbound-media";
+import "klaw/plugin-sdk/poll-runtime";
+import { formatZonedTimestamp } from "klaw/plugin-sdk/time-runtime";
+import "klaw/plugin-sdk/channel-feedback";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "klaw/plugin-sdk/runtime-group-policy";
+import "klaw/plugin-sdk/inbound-reply-dispatch";
+import "klaw/plugin-sdk/acp-binding-runtime";
+import { resolveOutboundSendDep } from "klaw/plugin-sdk/outbound-send-deps";
+export { jsonResult as a, readStringArrayParam as c, resolveDefaultGroupPolicy as d, resolveOutboundSendDep as f, warnMissingProviderGroupPolicyFallbackOnce as h, formatZonedTimestamp as i, readStringParam$1 as l, resolveThreadBindingMaxAgeMsForChannel as m, chunkTextForOutbound$1 as n, readNumberParam$1 as o, resolveThreadBindingIdleTimeoutMsForChannel as p, createActionGate$1 as r, readReactionParams as s, GROUP_POLICY_BLOCKED_LABEL as t, resolveAllowlistProviderRuntimeGroupPolicy as u };