@openclaw/matrix 2026.3.13 → 2026.5.9-beta.1

package/dist/recovery-key-store-BTJ6jz5v.js

@@ -0,0 +1,294 @@
+import { n as formatMatrixErrorReason, t as formatMatrixErrorMessage } from "./errors-CTcpEDq-.js";
+import { n as LogService } from "./logger-CnZRVrux.js";
+import { loadJsonFile, saveJsonFile } from "openclaw/plugin-sdk/json-store";
+import { decodeRecoveryKey } from "matrix-js-sdk/lib/crypto-api/recovery-key.js";
+//#region extensions/matrix/src/matrix/sdk/idb-persistence-lock.ts
+const MATRIX_IDB_PERSIST_INTERVAL_MS = 6e4;
+const IDB_SNAPSHOT_LOCK_STALE_MS = 5 * 6e4;
+const IDB_SNAPSHOT_LOCK_RETRY_BASE = {
+	factor: 2,
+	minTimeout: 50,
+	maxTimeout: 5e3,
+	randomize: true
+};
+function computeRetryDelayMs(retries, attempt) {
+	return Math.min(retries.maxTimeout, Math.max(retries.minTimeout, retries.minTimeout * retries.factor ** attempt));
+}
+function computeMinimumRetryWindowMs(retries) {
+	let total = 0;
+	const attempts = Math.max(1, retries.retries + 1);
+	for (let attempt = 0; attempt < attempts - 1; attempt += 1) total += computeRetryDelayMs(retries, attempt);
+	return total;
+}
+function resolveRetriesForMinimumWindowMs(retries, minimumWindowMs) {
+	const resolved = {
+		...retries,
+		retries: 0
+	};
+	while (computeMinimumRetryWindowMs(resolved) < minimumWindowMs) resolved.retries += 1;
+	return resolved;
+}
+const MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS = {
+	retries: resolveRetriesForMinimumWindowMs(IDB_SNAPSHOT_LOCK_RETRY_BASE, MATRIX_IDB_PERSIST_INTERVAL_MS),
+	stale: IDB_SNAPSHOT_LOCK_STALE_MS
+};
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/recovery-key-store.ts
+function isRepairableSecretStorageAccessError(err) {
+	const message = formatMatrixErrorReason(err);
+	if (!message) return false;
+	if (message.includes("getsecretstoragekey callback returned falsey")) return true;
+	if (message.includes("decrypting secret") && message.includes("bad mac")) return true;
+	return false;
+}
+var MatrixRecoveryKeyStore = class {
+	constructor(recoveryKeyPath) {
+		this.recoveryKeyPath = recoveryKeyPath;
+		this.secretStorageKeyCache = /* @__PURE__ */ new Map();
+		this.stagedRecoveryKey = null;
+		this.stagedRecoveryKeyUsed = false;
+		this.stagedCacheKeyIds = /* @__PURE__ */ new Set();
+	}
+	buildCryptoCallbacks() {
+		return {
+			getSecretStorageKey: async ({ keys }) => {
+				const requestedKeyIds = Object.keys(keys ?? {});
+				if (requestedKeyIds.length === 0) return null;
+				const staged = this.resolveStagedSecretStorageKey(requestedKeyIds);
+				if (staged) return staged;
+				for (const keyId of requestedKeyIds) {
+					const cached = this.secretStorageKeyCache.get(keyId);
+					if (cached) return [keyId, new Uint8Array(cached.key)];
+				}
+				const stored = this.loadStoredRecoveryKey();
+				if (!stored?.privateKeyBase64) return null;
+				const privateKey = new Uint8Array(Buffer.from(stored.privateKeyBase64, "base64"));
+				if (privateKey.length === 0) return null;
+				if (stored.keyId && requestedKeyIds.includes(stored.keyId)) {
+					this.rememberSecretStorageKey(stored.keyId, privateKey, stored.keyInfo);
+					return [stored.keyId, privateKey];
+				}
+				const firstRequestedKeyId = requestedKeyIds[0];
+				if (!firstRequestedKeyId) return null;
+				this.rememberSecretStorageKey(firstRequestedKeyId, privateKey, stored.keyInfo);
+				return [firstRequestedKeyId, privateKey];
+			},
+			cacheSecretStorageKey: (keyId, keyInfo, key) => {
+				const privateKey = new Uint8Array(key);
+				const normalizedKeyInfo = {
+					passphrase: keyInfo?.passphrase,
+					name: typeof keyInfo?.name === "string" ? keyInfo.name : void 0
+				};
+				this.rememberSecretStorageKey(keyId, privateKey, normalizedKeyInfo);
+				const stored = this.loadStoredRecoveryKey();
+				this.saveRecoveryKeyToDisk({
+					keyId,
+					keyInfo: normalizedKeyInfo,
+					privateKey,
+					encodedPrivateKey: stored?.encodedPrivateKey
+				});
+			}
+		};
+	}
+	getRecoveryKeySummary() {
+		const stored = this.loadStoredRecoveryKey();
+		if (!stored) return null;
+		return {
+			encodedPrivateKey: stored.encodedPrivateKey,
+			keyId: stored.keyId,
+			createdAt: stored.createdAt
+		};
+	}
+	resolveEncodedRecoveryKeyInput(params) {
+		const encodedPrivateKey = params.encodedPrivateKey.trim();
+		if (!encodedPrivateKey) throw new Error("Matrix recovery key is required");
+		let privateKey;
+		try {
+			privateKey = decodeRecoveryKey(encodedPrivateKey);
+		} catch (err) {
+			throw new Error(`Invalid Matrix recovery key: ${formatMatrixErrorMessage(err)}`, { cause: err });
+		}
+		const keyId = typeof params.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : null;
+		return {
+			encodedPrivateKey,
+			privateKey,
+			keyId,
+			keyInfo: params.keyInfo ?? this.loadStoredRecoveryKey()?.keyInfo
+		};
+	}
+	storeEncodedRecoveryKey(params) {
+		const prepared = this.resolveEncodedRecoveryKeyInput(params);
+		this.saveRecoveryKeyToDisk({
+			keyId: prepared.keyId,
+			keyInfo: prepared.keyInfo,
+			privateKey: prepared.privateKey,
+			encodedPrivateKey: prepared.encodedPrivateKey
+		});
+		if (prepared.keyId) this.rememberSecretStorageKey(prepared.keyId, prepared.privateKey, prepared.keyInfo);
+		return this.getRecoveryKeySummary() ?? {};
+	}
+	stageEncodedRecoveryKey(params) {
+		const prepared = this.resolveEncodedRecoveryKeyInput(params);
+		this.discardStagedRecoveryKey();
+		this.stagedRecoveryKey = {
+			version: 1,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			keyId: prepared.keyId,
+			encodedPrivateKey: prepared.encodedPrivateKey,
+			privateKeyBase64: Buffer.from(prepared.privateKey).toString("base64"),
+			keyInfo: prepared.keyInfo
+		};
+	}
+	hasStagedRecoveryKeyBeenUsed() {
+		return this.stagedRecoveryKeyUsed;
+	}
+	commitStagedRecoveryKey(params) {
+		if (!this.stagedRecoveryKey) return this.getRecoveryKeySummary();
+		const staged = this.stagedRecoveryKey;
+		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
+		const keyId = typeof params?.keyId === "string" && params.keyId.trim() ? params.keyId.trim() : staged.keyId;
+		this.saveRecoveryKeyToDisk({
+			keyId,
+			keyInfo: params?.keyInfo ?? staged.keyInfo,
+			privateKey,
+			encodedPrivateKey: staged.encodedPrivateKey
+		});
+		this.clearStagedRecoveryKeyTracking();
+		return this.getRecoveryKeySummary();
+	}
+	discardStagedRecoveryKey() {
+		for (const keyId of this.stagedCacheKeyIds) this.secretStorageKeyCache.delete(keyId);
+		this.clearStagedRecoveryKeyTracking();
+	}
+	async bootstrapSecretStorageWithRecoveryKey(crypto, options = {}) {
+		let status = null;
+		const getSecretStorageStatus = crypto.getSecretStorageStatus;
+		if (typeof getSecretStorageStatus === "function") try {
+			status = await getSecretStorageStatus.call(crypto);
+		} catch (err) {
+			LogService.warn("MatrixClientLite", "Failed to read secret storage status:", err);
+		}
+		const hasDefaultSecretStorageKey = Boolean(status?.defaultKeyId);
+		const hasKnownInvalidSecrets = Object.values(status?.secretStorageKeyValidityMap ?? {}).some((valid) => !valid);
+		let generatedRecoveryKey = false;
+		const storedRecovery = this.loadStoredRecoveryKey();
+		const stagedRecovery = this.stagedRecoveryKey;
+		const sourceRecovery = options.forceNewRecoveryKey === true ? null : stagedRecovery ?? storedRecovery;
+		let recoveryKey = sourceRecovery ? {
+			keyInfo: sourceRecovery.keyInfo,
+			privateKey: new Uint8Array(Buffer.from(sourceRecovery.privateKeyBase64, "base64")),
+			encodedPrivateKey: sourceRecovery.encodedPrivateKey
+		} : null;
+		if (recoveryKey && status?.defaultKeyId) {
+			const defaultKeyId = status.defaultKeyId;
+			if (!stagedRecovery) {
+				this.rememberSecretStorageKey(defaultKeyId, recoveryKey.privateKey, recoveryKey.keyInfo);
+				if (storedRecovery && storedRecovery.keyId !== defaultKeyId) this.saveRecoveryKeyToDisk({
+					keyId: defaultKeyId,
+					keyInfo: recoveryKey.keyInfo,
+					privateKey: recoveryKey.privateKey,
+					encodedPrivateKey: recoveryKey.encodedPrivateKey
+				});
+			}
+		}
+		const ensureRecoveryKey = async () => {
+			if (recoveryKey) {
+				if (stagedRecovery) this.stagedRecoveryKeyUsed = true;
+				return recoveryKey;
+			}
+			if (typeof crypto.createRecoveryKeyFromPassphrase !== "function") throw new Error("Matrix crypto backend does not support recovery key generation (createRecoveryKeyFromPassphrase missing)");
+			recoveryKey = await crypto.createRecoveryKeyFromPassphrase();
+			this.saveRecoveryKeyToDisk(recoveryKey);
+			generatedRecoveryKey = true;
+			return recoveryKey;
+		};
+		const shouldRecreateSecretStorage = options.forceNewSecretStorage === true || !hasDefaultSecretStorageKey || !recoveryKey && status?.ready === false || hasKnownInvalidSecrets;
+		if (hasKnownInvalidSecrets) recoveryKey = null;
+		const secretStorageOptions = { setupNewKeyBackup: options.setupNewKeyBackup === true };
+		if (shouldRecreateSecretStorage) {
+			secretStorageOptions.setupNewSecretStorage = true;
+			secretStorageOptions.createSecretStorageKey = ensureRecoveryKey;
+		}
+		try {
+			await crypto.bootstrapSecretStorage(secretStorageOptions);
+		} catch (err) {
+			if (!(options.allowSecretStorageRecreateWithoutRecoveryKey === true && hasDefaultSecretStorageKey && isRepairableSecretStorageAccessError(err))) throw err;
+			recoveryKey = null;
+			LogService.warn("MatrixClientLite", "Secret storage exists on the server but local recovery material cannot unlock it; recreating secret storage during explicit bootstrap.");
+			await crypto.bootstrapSecretStorage({
+				setupNewSecretStorage: true,
+				setupNewKeyBackup: options.setupNewKeyBackup === true,
+				createSecretStorageKey: ensureRecoveryKey
+			});
+		}
+		if (generatedRecoveryKey && this.recoveryKeyPath) LogService.warn("MatrixClientLite", `Generated Matrix recovery key and saved it to ${this.recoveryKeyPath}. Keep this file secure.`);
+	}
+	clearStagedRecoveryKeyTracking() {
+		this.stagedRecoveryKey = null;
+		this.stagedRecoveryKeyUsed = false;
+		this.stagedCacheKeyIds.clear();
+	}
+	resolveStagedSecretStorageKey(requestedKeyIds) {
+		const staged = this.stagedRecoveryKey;
+		if (!staged?.privateKeyBase64) return null;
+		const privateKey = new Uint8Array(Buffer.from(staged.privateKeyBase64, "base64"));
+		if (privateKey.length === 0) return null;
+		const keyId = staged.keyId && requestedKeyIds.includes(staged.keyId) ? staged.keyId : requestedKeyIds[0];
+		if (!keyId) return null;
+		this.rememberStagedSecretStorageKey(keyId, privateKey, staged.keyInfo);
+		this.stagedCacheKeyIds.add(keyId);
+		return [keyId, privateKey];
+	}
+	rememberStagedSecretStorageKey(keyId, key, keyInfo) {
+		this.stagedRecoveryKeyUsed = true;
+		this.rememberSecretStorageKey(keyId, key, keyInfo);
+	}
+	rememberSecretStorageKey(keyId, key, keyInfo) {
+		if (!keyId.trim()) return;
+		this.secretStorageKeyCache.set(keyId, {
+			key: new Uint8Array(key),
+			keyInfo
+		});
+	}
+	loadStoredRecoveryKey() {
+		if (!this.recoveryKeyPath) return null;
+		try {
+			const parsed = loadJsonFile(this.recoveryKeyPath);
+			if (parsed?.version !== 1 || typeof parsed.createdAt !== "string" || typeof parsed.privateKeyBase64 !== "string" || !parsed.privateKeyBase64.trim()) return null;
+			return {
+				version: 1,
+				createdAt: parsed.createdAt,
+				keyId: typeof parsed.keyId === "string" ? parsed.keyId : null,
+				encodedPrivateKey: typeof parsed.encodedPrivateKey === "string" ? parsed.encodedPrivateKey : void 0,
+				privateKeyBase64: parsed.privateKeyBase64,
+				keyInfo: parsed.keyInfo && typeof parsed.keyInfo === "object" ? {
+					passphrase: parsed.keyInfo.passphrase,
+					name: typeof parsed.keyInfo.name === "string" ? parsed.keyInfo.name : void 0
+				} : void 0
+			};
+		} catch {
+			return null;
+		}
+	}
+	saveRecoveryKeyToDisk(params) {
+		if (!this.recoveryKeyPath) return;
+		try {
+			const payload = {
+				version: 1,
+				createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+				keyId: typeof params.keyId === "string" ? params.keyId : null,
+				encodedPrivateKey: params.encodedPrivateKey,
+				privateKeyBase64: Buffer.from(params.privateKey).toString("base64"),
+				keyInfo: params.keyInfo ? {
+					passphrase: params.keyInfo.passphrase,
+					name: params.keyInfo.name
+				} : void 0
+			};
+			saveJsonFile(this.recoveryKeyPath, payload);
+		} catch (err) {
+			LogService.warn("MatrixClientLite", "Failed to persist recovery key:", err);
+		}
+	}
+};
+//#endregion
+export { MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS as i, isRepairableSecretStorageAccessError as n, MATRIX_IDB_PERSIST_INTERVAL_MS as r, MatrixRecoveryKeyStore as t };

package/dist/resolve-targets-YtJnw1Tb.js

@@ -0,0 +1,140 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-80nQ2gql.js";
+import { n as listMatrixDirectoryGroupsLive, r as listMatrixDirectoryPeersLive } from "./directory-live-DmOtMhyr.js";
+import { normalizeOptionalLowercaseString } from "openclaw/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-D9piiGEl.js

@@ -0,0 +1,5 @@
+import { t as resolveMatrixTargets } from "./resolve-targets-YtJnw1Tb.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-D6rg-iXN.js

@@ -0,0 +1,161 @@
+import { n as MATRIX_REACTION_EVENT_TYPE } from "./reaction-common-ejrL19w-.js";
+import { buildAgentSessionKey, deriveLastRoutePolicy, resolveAgentIdFromSessionKey, resolveThreadSessionKeys } from "openclaw/plugin-sdk/routing";
+import { resolveConfiguredAcpBindingRecord } from "openclaw/plugin-sdk/acp-binding-resolve-runtime";
+import { getSessionBindingService } from "openclaw/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-C6X4h_SJ.js

@@ -0,0 +1,6 @@
+//#region extensions/matrix/src/matrix/client/runtime.ts
+function isBunRuntime() {
+	return typeof process.versions.bun === "string";
+}
+//#endregion
+export { isBunRuntime as t };

package/dist/runtime-Dog86njy.js

@@ -0,0 +1,8 @@
+import { createPluginRuntimeStore } from "openclaw/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-BXWBFIqm.js

@@ -0,0 +1,25 @@
+import "./timeout-abort-signal-CtaIaP1v.js";
+import "openclaw/plugin-sdk/account-id";
+import { resolveThreadBindingIdleTimeoutMsForChannel, resolveThreadBindingMaxAgeMsForChannel } from "openclaw/plugin-sdk/conversation-runtime";
+import "openclaw/plugin-sdk/channel-message";
+import "openclaw/plugin-sdk/channel-policy";
+import { chunkTextForOutbound as chunkTextForOutbound$1 } from "openclaw/plugin-sdk/text-chunking";
+import { createActionGate as createActionGate$1, jsonResult, readNumberParam as readNumberParam$1, readReactionParams, readStringArrayParam, readStringParam as readStringParam$1 } from "openclaw/plugin-sdk/channel-actions";
+import "openclaw/plugin-sdk/routing";
+import "openclaw/plugin-sdk/channel-status";
+import "openclaw/plugin-sdk/channel-config-primitives";
+import "openclaw/plugin-sdk/ssrf-runtime";
+import "openclaw/plugin-sdk/channel-location";
+import "openclaw/plugin-sdk/channel-logging";
+import "openclaw/plugin-sdk/channel-targets";
+import "openclaw/plugin-sdk/setup";
+import "openclaw/plugin-sdk/json-store";
+import "openclaw/plugin-sdk/outbound-media";
+import "openclaw/plugin-sdk/poll-runtime";
+import { formatZonedTimestamp } from "openclaw/plugin-sdk/time-runtime";
+import "openclaw/plugin-sdk/channel-feedback";
+import { GROUP_POLICY_BLOCKED_LABEL, resolveAllowlistProviderRuntimeGroupPolicy, resolveDefaultGroupPolicy, warnMissingProviderGroupPolicyFallbackOnce } from "openclaw/plugin-sdk/runtime-group-policy";
+import "openclaw/plugin-sdk/inbound-reply-dispatch";
+import "openclaw/plugin-sdk/acp-binding-runtime";
+import { resolveOutboundSendDep } from "openclaw/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 };