@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/onboarding-hJaieQj5.mjs

@@ -0,0 +1,482 @@
+import { i as __exportAll } from "./doctor-contract-De6geW0h.mjs";
+import { i as requiresExplicitMatrixDefaultAccount, u as resolveMatrixEnvAuthReadiness } from "./account-selection-B7axQ80R.mjs";
+import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { a as resolveMatrixAccountAsync, r as resolveDefaultMatrixAccountId, t as listMatrixAccountIds } from "./accounts-WkgrIxMt.mjs";
+import { n as isMatrixRoomId } from "./target-ids-Nwx7cMVE.mjs";
+import { n as updateMatrixAccountConfig } from "./config-update-5m1Un5gJ.mjs";
+import { a as moveSingleMatrixAccountConfigToNamedAccount, i as createMatrixSetupDmPolicy } from "./setup-core-BeifoeL4.mjs";
+import { n as validateMatrixHomeserverUrl, t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-CF6pG6eE.mjs";
+import { n as ensureMatrixSdkInstalled, r as isMatrixSdkAvailable } from "./deps-CLQ4EOq7.mjs";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeStringifiedOptionalString, normalizeUniqueStringEntries } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { formatDocsLink, hasConfiguredSecretInput, mergeAllowFromEntries, normalizeAccountId as normalizeAccountId$1, promptAccountId, promptChannelAccessConfig, setSetupChannelEnabled, splitSetupEntries } from "openclaw/plugin-sdk/setup";
+import { isPrivateNetworkOptInEnabled } from "openclaw/plugin-sdk/ssrf-policy";
+import { isPrivateOrLoopbackHost } from "openclaw/plugin-sdk/ssrf-runtime";
+//#region extensions/matrix/src/onboarding.ts
+var onboarding_exports = /* @__PURE__ */ __exportAll({ matrixOnboardingAdapter: () => matrixOnboardingAdapter });
+const channel = "matrix";
+const matrixInviteAutoJoinOptions = [
+	{
+		value: "allowlist",
+		label: "Allowlist (recommended)"
+	},
+	{
+		value: "always",
+		label: "Always (join every invite)"
+	},
+	{
+		value: "off",
+		label: "Off (do not auto-join invites)"
+	}
+];
+function isMatrixInviteAutoJoinPolicy(value) {
+	return value === "allowlist" || value === "always" || value === "off";
+}
+function isMatrixInviteAutoJoinTarget(entry) {
+	return entry === "*" || isMatrixRoomId(entry) || entry.startsWith("#") && entry.includes(":");
+}
+function resolveMatrixOnboardingAccountId(cfg, accountId) {
+	return normalizeAccountId$1(normalizeOptionalString(accountId) || resolveDefaultMatrixAccountId(cfg) || DEFAULT_ACCOUNT_ID);
+}
+async function noteMatrixAuthHelp(prompter) {
+	await prompter.note([
+		"Matrix requires a homeserver URL.",
+		"Use an access token (recommended) or password login to an existing account.",
+		"With access token: user ID is fetched automatically.",
+		"Env vars supported: MATRIX_HOMESERVER, MATRIX_USER_ID, MATRIX_ACCESS_TOKEN, MATRIX_PASSWORD, MATRIX_DEVICE_ID, MATRIX_DEVICE_NAME.",
+		"Per-account env vars: MATRIX_<ACCOUNT_ID>_HOMESERVER, MATRIX_<ACCOUNT_ID>_USER_ID, MATRIX_<ACCOUNT_ID>_ACCESS_TOKEN, MATRIX_<ACCOUNT_ID>_PASSWORD, MATRIX_<ACCOUNT_ID>_DEVICE_ID, MATRIX_<ACCOUNT_ID>_DEVICE_NAME.",
+		`Docs: ${formatDocsLink("/channels/matrix", "channels/matrix")}`
+	].join("\n"), "Matrix setup");
+}
+function requiresMatrixPrivateNetworkOptIn(homeserver) {
+	try {
+		const parsed = new URL(homeserver);
+		return parsed.protocol === "http:" && !isPrivateOrLoopbackHost(parsed.hostname);
+	} catch {
+		return false;
+	}
+}
+async function promptMatrixAllowFrom(params) {
+	const { cfg, prompter } = params;
+	const accountId = resolveMatrixOnboardingAccountId(cfg, params.accountId);
+	const existingConfig = resolveMatrixAccountConfig({
+		cfg,
+		accountId
+	});
+	const existingAllowFrom = existingConfig.dm?.allowFrom ?? [];
+	const canResolve = (await resolveMatrixAccountAsync({
+		cfg,
+		accountId
+	})).configured;
+	const isFullUserId = (value) => value.startsWith("@") && value.includes(":");
+	while (true) {
+		const entry = await prompter.text({
+			message: "Matrix allowFrom (full @user:server; display name only if unique)",
+			placeholder: "@user:server",
+			initialValue: existingAllowFrom[0] ? String(existingAllowFrom[0]) : void 0,
+			validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+		});
+		const parts = splitSetupEntries(entry);
+		const resolvedIds = [];
+		const pending = [];
+		const unresolved = [];
+		const unresolvedNotes = [];
+		for (const part of parts) {
+			if (isFullUserId(part)) {
+				resolvedIds.push(part);
+				continue;
+			}
+			if (!canResolve) {
+				unresolved.push(part);
+				continue;
+			}
+			pending.push(part);
+		}
+		if (pending.length > 0) {
+			const { resolveMatrixTargets } = await import("./resolve-targets-BFq3q4c9.mjs").then((n) => n.n);
+			const results = await resolveMatrixTargets({
+				cfg,
+				accountId,
+				inputs: pending,
+				kind: "user"
+			}).catch(() => []);
+			for (const result of results) {
+				if (result?.resolved && result.id) {
+					resolvedIds.push(result.id);
+					continue;
+				}
+				if (result?.input) {
+					unresolved.push(result.input);
+					if (result.note) unresolvedNotes.push(`${result.input}: ${result.note}`);
+				}
+			}
+		}
+		if (unresolved.length > 0) {
+			const details = unresolvedNotes.length > 0 ? unresolvedNotes : unresolved;
+			await prompter.note(`Could not resolve:\n${details.join("\n")}\nUse full @user:server IDs.`, "Matrix allowlist");
+			continue;
+		}
+		const unique = mergeAllowFromEntries(existingAllowFrom, resolvedIds);
+		return updateMatrixAccountConfig(cfg, accountId, { dm: {
+			...existingConfig.dm,
+			policy: "allowlist",
+			allowFrom: unique
+		} });
+	}
+}
+function setMatrixAutoJoin(cfg, autoJoin, autoJoinAllowlist, accountId) {
+	return updateMatrixAccountConfig(cfg, resolveMatrixOnboardingAccountId(cfg, accountId), {
+		autoJoin,
+		autoJoinAllowlist: autoJoin === "allowlist" ? autoJoinAllowlist : null
+	});
+}
+async function configureMatrixInviteAutoJoin(params) {
+	const accountId = resolveMatrixOnboardingAccountId(params.cfg, params.accountId);
+	const existingConfig = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId
+	});
+	const currentPolicy = existingConfig.autoJoin ?? "off";
+	const currentAllowlist = (existingConfig.autoJoinAllowlist ?? []).map((entry) => String(entry));
+	const hasExistingConfig = existingConfig.autoJoin !== void 0 || currentAllowlist.length > 0;
+	await params.prompter.note([
+		"WARNING: Matrix invite auto-join defaults to off.",
+		"OpenClaw agents will not join invited rooms or fresh DM-style invites unless you set autoJoin.",
+		"Choose \"allowlist\" to restrict joins or \"always\" to join every invite."
+	].join("\n"), "Matrix invite auto-join");
+	if (!await params.prompter.confirm({
+		message: hasExistingConfig ? "Update Matrix invite auto-join?" : "Configure Matrix invite auto-join?",
+		initialValue: hasExistingConfig ? currentPolicy !== "off" : true
+	})) return params.cfg;
+	const selectedPolicy = await params.prompter.select({
+		message: "Matrix invite auto-join",
+		options: matrixInviteAutoJoinOptions,
+		initialValue: currentPolicy
+	});
+	if (!isMatrixInviteAutoJoinPolicy(selectedPolicy)) throw new Error(`Unsupported Matrix invite auto-join policy: ${String(selectedPolicy)}`);
+	const policy = selectedPolicy;
+	if (policy === "off") {
+		await params.prompter.note(["Matrix invite auto-join remains off.", "Agents will not join invited rooms or fresh DM-style invites until you change autoJoin."].join("\n"), "Matrix invite auto-join");
+		return setMatrixAutoJoin(params.cfg, policy, [], accountId);
+	}
+	if (policy === "always") return setMatrixAutoJoin(params.cfg, policy, [], accountId);
+	while (true) {
+		const rawAllowlist = await params.prompter.text({
+			message: "Matrix invite auto-join allowlist (comma-separated)",
+			placeholder: "!roomId:server, !roomId, #alias:server, *",
+			initialValue: currentAllowlist[0] ? currentAllowlist.join(", ") : void 0,
+			validate: (value) => {
+				return splitSetupEntries(value).length > 0 ? void 0 : "Required";
+			}
+		});
+		const allowlist = normalizeUniqueStringEntries(splitSetupEntries(rawAllowlist));
+		const invalidEntries = allowlist.filter((entry) => !isMatrixInviteAutoJoinTarget(entry));
+		if (allowlist.length === 0 || invalidEntries.length > 0) {
+			await params.prompter.note(["Use only stable Matrix invite targets for auto-join: !roomId:server (or the suffixless !roomId form on room version 12+), #alias:server, or *.", invalidEntries.length > 0 ? `Invalid: ${invalidEntries.join(", ")}` : void 0].filter(Boolean).join("\n"), "Matrix invite auto-join");
+			continue;
+		}
+		return setMatrixAutoJoin(params.cfg, "allowlist", allowlist, accountId);
+	}
+}
+async function configureMatrixAccessPrompts(params) {
+	let next = params.cfg;
+	if (params.forceAllowFrom) next = await promptMatrixAllowFrom({
+		cfg: next,
+		prompter: params.prompter,
+		accountId: params.accountId
+	});
+	const existingAccountConfig = resolveMatrixAccountConfig({
+		cfg: next,
+		accountId: params.accountId
+	});
+	const existingGroups = existingAccountConfig.groups ?? existingAccountConfig.rooms;
+	const accessConfig = await promptChannelAccessConfig({
+		prompter: params.prompter,
+		label: "Matrix rooms",
+		currentPolicy: existingAccountConfig.groupPolicy ?? "allowlist",
+		currentEntries: Object.keys(existingGroups ?? {}),
+		placeholder: "!roomId:server, !roomId, #alias:server, Project Room",
+		updatePrompt: Boolean(existingGroups)
+	});
+	if (accessConfig) {
+		if (accessConfig.policy !== "allowlist") next = updateMatrixAccountConfig(next, params.accountId, { groupPolicy: accessConfig.policy });
+		else {
+			let roomKeys = accessConfig.entries;
+			if (accessConfig.entries.length > 0) try {
+				const resolvedIds = [];
+				const unresolved = [];
+				for (const entry of accessConfig.entries) {
+					const trimmed = normalizeOptionalString(entry) ?? "";
+					if (!trimmed) continue;
+					const cleaned = trimmed.replace(/^(room|channel):/i, "").trim();
+					if (isMatrixRoomId(cleaned)) {
+						resolvedIds.push(cleaned);
+						continue;
+					}
+					const { listMatrixDirectoryGroupsLive } = await import("./directory-live-_sw-Q7KO.mjs").then((n) => n.t);
+					const matches = await listMatrixDirectoryGroupsLive({
+						cfg: next,
+						accountId: params.accountId,
+						query: trimmed,
+						limit: 10
+					});
+					const best = matches.find((match) => normalizeLowercaseStringOrEmpty(match.name) === normalizeLowercaseStringOrEmpty(trimmed)) ?? matches[0];
+					if (best?.id) resolvedIds.push(best.id);
+					else unresolved.push(entry);
+				}
+				roomKeys = [...resolvedIds, ...unresolved.map((entry) => normalizeOptionalString(entry)).filter((entry) => Boolean(entry))];
+				if (resolvedIds.length > 0 || unresolved.length > 0) await params.prompter.note([resolvedIds.length > 0 ? `Resolved: ${resolvedIds.join(", ")}` : void 0, unresolved.length > 0 ? `Unresolved (kept as typed): ${unresolved.join(", ")}` : void 0].filter(Boolean).join("\n"), "Matrix rooms");
+			} catch (err) {
+				await params.prompter.note(`Room lookup failed; keeping entries as typed. ${String(err)}`, "Matrix rooms");
+			}
+			next = updateMatrixAccountConfig(next, params.accountId, {
+				groupPolicy: "allowlist",
+				groups: Object.fromEntries(roomKeys.map((key) => [key, { enabled: true }])),
+				rooms: null
+			});
+		}
+	}
+	return await configureMatrixInviteAutoJoin({
+		cfg: next,
+		prompter: params.prompter,
+		accountId: params.accountId
+	});
+}
+const dmPolicy = createMatrixSetupDmPolicy(promptMatrixAllowFrom);
+async function runMatrixConfigure(params) {
+	let next = params.cfg;
+	const promptText = async (options) => normalizeStringifiedOptionalString(await params.prompter.text(options)) ?? "";
+	await ensureMatrixSdkInstalled({
+		runtime: params.runtime,
+		confirm: async (message) => await params.prompter.confirm({
+			message,
+			initialValue: true
+		})
+	});
+	const defaultAccountId = resolveDefaultMatrixAccountId(next);
+	let accountId = defaultAccountId || DEFAULT_ACCOUNT_ID;
+	if (params.intent === "add-account") {
+		const enteredName = await promptText({
+			message: "Matrix account name",
+			validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+		});
+		accountId = normalizeAccountId$1(enteredName);
+		if (enteredName !== accountId) await params.prompter.note(`Account id will be "${accountId}".`, "Matrix account");
+		if (accountId !== DEFAULT_ACCOUNT_ID) next = moveSingleMatrixAccountConfigToNamedAccount(next);
+		next = updateMatrixAccountConfig(next, accountId, {
+			name: enteredName,
+			enabled: true
+		});
+	} else {
+		const override = normalizeOptionalString(params.accountOverrides?.[channel]);
+		if (override) accountId = normalizeAccountId$1(override);
+		else if (params.shouldPromptAccountIds) accountId = await promptAccountId({
+			cfg: next,
+			prompter: params.prompter,
+			label: "Matrix",
+			currentId: accountId,
+			listAccountIds: (inputCfg) => listMatrixAccountIds(inputCfg),
+			defaultAccountId
+		});
+	}
+	const existing = resolveMatrixAccountConfig({
+		cfg: next,
+		accountId
+	});
+	if (!(await resolveMatrixAccountAsync({
+		cfg: next,
+		accountId
+	})).configured) await noteMatrixAuthHelp(params.prompter);
+	const envReadiness = resolveMatrixEnvAuthReadiness(accountId, process.env);
+	const envReady = envReadiness.ready;
+	const envHomeserver = envReadiness.homeserver;
+	const envUserId = envReadiness.userId;
+	if (envReady && !existing.homeserver && !existing.userId && !existing.accessToken && !existing.password) {
+		if (await params.prompter.confirm({
+			message: `Matrix env vars detected (${envReadiness.sourceHint}). Use env values?`,
+			initialValue: true
+		})) {
+			next = updateMatrixAccountConfig(next, accountId, { enabled: true });
+			next = await configureMatrixAccessPrompts({
+				cfg: next,
+				prompter: params.prompter,
+				forceAllowFrom: params.forceAllowFrom,
+				accountId
+			});
+			return {
+				cfg: next,
+				accountId
+			};
+		}
+	}
+	const homeserver = await promptText({
+		message: "Matrix homeserver URL",
+		initialValue: existing.homeserver ?? envHomeserver,
+		validate: (value) => {
+			try {
+				validateMatrixHomeserverUrl(value, { allowPrivateNetwork: true });
+				return;
+			} catch (error) {
+				return error instanceof Error ? error.message : "Invalid Matrix homeserver URL";
+			}
+		}
+	});
+	const requiresAllowPrivateNetwork = requiresMatrixPrivateNetworkOptIn(homeserver);
+	const shouldPromptAllowPrivateNetwork = requiresAllowPrivateNetwork || isPrivateNetworkOptInEnabled(existing);
+	const allowPrivateNetwork = shouldPromptAllowPrivateNetwork ? await params.prompter.confirm({
+		message: "Allow private/internal Matrix homeserver traffic for this account?",
+		initialValue: isPrivateNetworkOptInEnabled(existing) || requiresAllowPrivateNetwork
+	}) : false;
+	if (requiresAllowPrivateNetwork && !allowPrivateNetwork) throw new Error("Matrix homeserver requires explicit private-network opt-in");
+	await resolveValidatedMatrixHomeserverUrl(homeserver, { dangerouslyAllowPrivateNetwork: allowPrivateNetwork });
+	let accessToken = existing.accessToken;
+	let password = existing.password;
+	let userId = existing.userId ?? "";
+	if (hasConfiguredSecretInput(accessToken) || hasConfiguredSecretInput(password)) {
+		if (!await params.prompter.confirm({
+			message: "Matrix credentials already configured. Keep them?",
+			initialValue: true
+		})) {
+			accessToken = void 0;
+			password = void 0;
+			userId = "";
+		}
+	}
+	if (!hasConfiguredSecretInput(accessToken) && !hasConfiguredSecretInput(password)) {
+		if (await params.prompter.select({
+			message: "Matrix auth method",
+			options: [{
+				value: "token",
+				label: "Access token (user ID fetched automatically)"
+			}, {
+				value: "password",
+				label: "Password (requires user ID)"
+			}]
+		}) === "token") {
+			accessToken = await promptText({
+				message: "Matrix access token",
+				sensitive: true,
+				validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+			});
+			password = void 0;
+			userId = "";
+		} else {
+			userId = await promptText({
+				message: "Matrix user ID",
+				initialValue: existing.userId ?? envUserId,
+				validate: (value) => {
+					const raw = normalizeOptionalString(value) ?? "";
+					if (!raw) return "Required";
+					if (!raw.startsWith("@")) return "Matrix user IDs should start with @";
+					if (!raw.includes(":")) return "Matrix user IDs should include a server (:server)";
+				}
+			});
+			password = await promptText({
+				message: "Matrix password",
+				sensitive: true,
+				validate: (value) => normalizeOptionalString(value) ? void 0 : "Required"
+			});
+			accessToken = void 0;
+		}
+	}
+	const deviceName = await promptText({
+		message: "Matrix device name (optional)",
+		initialValue: existing.deviceName ?? "OpenClaw Gateway"
+	});
+	const enableEncryption = await params.prompter.confirm({
+		message: "Enable end-to-end encryption (E2EE)?",
+		initialValue: existing.encryption ?? false
+	});
+	next = updateMatrixAccountConfig(next, accountId, {
+		enabled: true,
+		homeserver,
+		...shouldPromptAllowPrivateNetwork ? { allowPrivateNetwork: allowPrivateNetwork ? true : null } : {},
+		userId: userId || null,
+		accessToken: accessToken ?? null,
+		password: password ?? null,
+		deviceName: deviceName || null,
+		encryption: enableEncryption
+	});
+	next = await configureMatrixAccessPrompts({
+		cfg: next,
+		prompter: params.prompter,
+		forceAllowFrom: params.forceAllowFrom,
+		accountId
+	});
+	return {
+		cfg: next,
+		accountId
+	};
+}
+const matrixOnboardingAdapter = {
+	channel,
+	getStatus: async ({ cfg, accountOverrides }) => {
+		const resolvedCfg = cfg;
+		const sdkReady = isMatrixSdkAvailable();
+		if (!accountOverrides[channel] && requiresExplicitMatrixDefaultAccount(resolvedCfg)) return {
+			channel,
+			configured: false,
+			statusLines: ["Matrix: set \"channels.matrix.defaultAccount\" to select a named account"],
+			selectionHint: !sdkReady ? "install Matrix deps" : "set defaultAccount"
+		};
+		const configured = (await resolveMatrixAccountAsync({
+			cfg: resolvedCfg,
+			accountId: resolveMatrixOnboardingAccountId(resolvedCfg, accountOverrides[channel])
+		})).configured;
+		return {
+			channel,
+			configured,
+			statusLines: [`Matrix: ${configured ? "configured" : "needs homeserver + access token or password"}`],
+			selectionHint: !sdkReady ? "install Matrix deps" : configured ? "configured" : "needs auth"
+		};
+	},
+	configure: async (params) => await runMatrixConfigure({
+		...params,
+		cfg: params.cfg,
+		intent: "update"
+	}),
+	configureInteractive: async (params) => {
+		if (!params.configured) return await runMatrixConfigure({
+			...params,
+			cfg: params.cfg,
+			intent: "update"
+		});
+		const action = await params.prompter.select({
+			message: "Matrix already configured. What do you want to do?",
+			options: [
+				{
+					value: "update",
+					label: "Modify settings"
+				},
+				{
+					value: "add-account",
+					label: "Add account"
+				},
+				{
+					value: "skip",
+					label: "Skip (leave as-is)"
+				}
+			],
+			initialValue: "update"
+		});
+		if (action === "skip") return "skip";
+		return await runMatrixConfigure({
+			...params,
+			cfg: params.cfg,
+			intent: action === "add-account" ? "add-account" : "update"
+		});
+	},
+	afterConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
+		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-AzalcuCW.mjs");
+		await runMatrixSetupBootstrapAfterConfigWrite({
+			previousCfg,
+			cfg,
+			accountId,
+			runtime
+		});
+	},
+	dmPolicy,
+	disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
+};
+//#endregion
+export { onboarding_exports as n, matrixOnboardingAdapter as t };

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

@@ -0,0 +1,199 @@
+import { r as matrixPresentationCapabilities } from "./channel-DXenXmj0.mjs";
+import { i as sendPollMatrix, r as sendMessageMatrix } from "./send-GOF64QRc.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 = "---";
+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 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]: {
+					...params.presentation,
+					version: 1,
+					type: MATRIX_OPENCLAW_PRESENTATION_TYPE
+				} }
+			}
+		}
+	};
+}
+function prepareMatrixReplyPayload(payload) {
+	return renderPresentationForDelivery({
+		presentationCapabilities: matrixPresentationCapabilities,
+		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;
+}
+async function sendMatrixOutbound(ctx, media) {
+	const result = await (resolveOutboundSendDep(ctx.deps, "matrix") ?? sendMessageMatrix)(ctx.to, ctx.text, {
+		cfg: ctx.cfg,
+		...media,
+		replyToId: ctx.replyToId ?? void 0,
+		threadId: ctx.threadId != null ? String(ctx.threadId) : void 0,
+		accountId: ctx.accountId ?? void 0,
+		audioAsVoice: ctx.audioAsVoice,
+		deliveryQueueId: ctx.deliveryQueueId,
+		deliveryPartIndex: ctx.deliveryPartIndex,
+		...ctx.deliveryQueueId !== void 0 ? { deliveryPartCount: ctx.deliveryPartCount } : {},
+		signal: ctx.signal,
+		assertDirectAdapterHandoff: ctx.assertDirectAdapterHandoff,
+		onPlatformSendDispatch: ctx.onPlatformSendDispatch,
+		onDeliveryResult: resolveMatrixDeliveryProgress(ctx.onDeliveryResult)
+	});
+	return attachChannelToResult("matrix", toMatrixOutboundResult(result));
+}
+const matrixOutbound = {
+	deliveryMode: "direct",
+	chunker: chunkTextForOutbound,
+	chunkerMode: "markdown",
+	textChunkLimit: 4e3,
+	presentationCapabilities: matrixPresentationCapabilities,
+	renderPresentation: renderMatrixPresentationPayload,
+	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: (ctx) => sendMatrixOutbound(ctx),
+	sendMedia: (ctx) => sendMatrixOutbound(ctx, {
+		mediaUrl: ctx.mediaUrl,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile,
+		mediaAccess: ctx.mediaAccess
+	}),
+	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 };