@gaodefa/daocore 2026.5.29 → 2026.5.30

package/dist/token-BbGCANnE.js

@@ -0,0 +1,134 @@
+import { d as normalizeSecretInputString, h as resolveSecretInputString } from "./types.secrets-Ct1DNG7D.js";
+import { n as normalizeAccountId, t as DEFAULT_ACCOUNT_ID } from "./account-id-B32J-iNN.js";
+import { a as tryReadSecretFileSync } from "./secret-file-Yf6gWwVs.js";
+import { l as resolveDefaultSecretProviderAlias } from "./ref-contract-D77qqtrn.js";
+import { n as resolveNormalizedAccountEntry } from "./account-lookup-CQEoGO1F.js";
+import "./account-core-B_TIp73g.js";
+import "./channel-core-Dz9I_R4j.js";
+import "./provider-auth-B-d9TlzW.js";
+import "./routing-AC-P99jg.js";
+import "./secret-input-s8BgZnEq.js";
+//#region extensions/telegram/src/token.ts
+function resolveEnvSecretRefValue(params) {
+	const providerConfig = params.cfg?.secrets?.providers?.[params.provider];
+	if (providerConfig) {
+		if (providerConfig.source !== "env") throw new Error(`Secret provider "${params.provider}" has source "${providerConfig.source}" but ref requests "env".`);
+		if (providerConfig.allowlist && !providerConfig.allowlist.includes(params.id)) throw new Error(`Environment variable "${params.id}" is not allowlisted in secrets.providers.${params.provider}.allowlist.`);
+	} else if (params.provider !== resolveDefaultSecretProviderAlias({ secrets: params.cfg?.secrets }, "env")) throw new Error(`Secret provider "${params.provider}" is not configured (ref: env:${params.provider}:${params.id}).`);
+	return normalizeSecretInputString((params.env ?? process.env)[params.id]);
+}
+function resolveRuntimeTokenValue(params) {
+	const resolved = resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg?.secrets?.defaults,
+		mode: "inspect"
+	});
+	if (resolved.status === "available") return {
+		status: "available",
+		value: resolved.value
+	};
+	if (resolved.status === "missing") return { status: "missing" };
+	if (resolved.ref.source === "env") {
+		const envValue = resolveEnvSecretRefValue({
+			cfg: params.cfg,
+			provider: resolved.ref.provider,
+			id: resolved.ref.id
+		});
+		if (envValue) return {
+			status: "available",
+			value: envValue
+		};
+		return { status: "configured_unavailable" };
+	}
+	resolveSecretInputString({
+		value: params.value,
+		path: params.path,
+		defaults: params.cfg?.secrets?.defaults,
+		mode: "strict"
+	});
+	return { status: "configured_unavailable" };
+}
+function resolveTelegramToken(cfg, opts = {}) {
+	const accountId = normalizeAccountId(opts.accountId);
+	const telegramCfg = cfg?.channels?.telegram;
+	const resolveAccountCfg = (id) => {
+		const accounts = telegramCfg?.accounts;
+		return Array.isArray(accounts) ? void 0 : resolveNormalizedAccountEntry(accounts, id, normalizeAccountId);
+	};
+	const accountCfg = resolveAccountCfg(accountId !== "default" ? accountId : DEFAULT_ACCOUNT_ID);
+	if (accountId !== "default" && !accountCfg) {
+		const accounts = telegramCfg?.accounts;
+		if (!!accounts && typeof accounts === "object" && !Array.isArray(accounts) && Object.keys(accounts).length > 0) {
+			opts.logMissingFile?.(`channels.telegram.accounts: unknown accountId "${accountId}" — not found in config, refusing channel-level fallback`);
+			return {
+				token: "",
+				source: "none"
+			};
+		}
+	}
+	const accountTokenFile = accountCfg?.tokenFile?.trim();
+	if (accountTokenFile) {
+		const token = tryReadSecretFileSync(accountTokenFile, `channels.telegram.accounts.${accountId}.tokenFile`, { rejectSymlink: true });
+		if (token) return {
+			token,
+			source: "tokenFile"
+		};
+		opts.logMissingFile?.(`channels.telegram.accounts.${accountId}.tokenFile not found or unreadable: ${accountTokenFile}`);
+		return {
+			token: "",
+			source: "none"
+		};
+	}
+	const accountToken = resolveRuntimeTokenValue({
+		cfg,
+		value: accountCfg?.botToken,
+		path: `channels.telegram.accounts.${accountId}.botToken`
+	});
+	if (accountToken.status === "available") return {
+		token: accountToken.value,
+		source: "config"
+	};
+	if (accountToken.status === "configured_unavailable") return {
+		token: "",
+		source: "none"
+	};
+	const allowEnv = accountId === DEFAULT_ACCOUNT_ID;
+	const tokenFile = telegramCfg?.tokenFile?.trim();
+	if (tokenFile) {
+		const token = tryReadSecretFileSync(tokenFile, "channels.telegram.tokenFile", { rejectSymlink: true });
+		if (token) return {
+			token,
+			source: "tokenFile"
+		};
+		opts.logMissingFile?.(`channels.telegram.tokenFile not found or unreadable: ${tokenFile}`);
+		return {
+			token: "",
+			source: "none"
+		};
+	}
+	const configToken = resolveRuntimeTokenValue({
+		cfg,
+		value: telegramCfg?.botToken,
+		path: "channels.telegram.botToken"
+	});
+	if (configToken.status === "available") return {
+		token: configToken.value,
+		source: "config"
+	};
+	if (configToken.status === "configured_unavailable") return {
+		token: "",
+		source: "none"
+	};
+	const envToken = allowEnv ? (opts.envToken ?? process.env.TELEGRAM_BOT_TOKEN)?.trim() : "";
+	if (envToken) return {
+		token: envToken,
+		source: "env"
+	};
+	return {
+		token: "",
+		source: "none"
+	};
+}
+//#endregion
+export { resolveTelegramToken as t };

package/dist/tool-actions.runtime-oUUrD8HB.js

@@ -0,0 +1,534 @@
+import { s as normalizeOptionalLowercaseString } from "./string-coerce-DyL154ka.js";
+import { c as jsonResult, f as readNumberParam, g as readStringParam, i as createActionGate, m as readStringArrayParam, p as readReactionParams } from "./common-vJyw6dD-.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { a as resolveMatrixAccountConfig } from "./account-config-wMhN5mBi.js";
+import "./accounts-DQa5og50.js";
+import { _ as parsePollStart, d as buildPollResponseContent, g as isPollStartType, i as reactMatrixMessage, u as resolveMatrixRoomId } from "./send-CQTcckeM.js";
+import { i as buildMatrixReactionRelationsPath, o as selectOwnMatrixReactionEventIds, s as summarizeMatrixReactionEvents } from "./reaction-common-DkiCrQAw.js";
+import { n as withResolvedRoomAction, t as withResolvedActionClient } from "./client-DafOw3oF.js";
+import { a as fetchEventSummary, c as resolveMatrixActionLimit, i as sendMatrixMessage, n as editMatrixMessage, o as readPinnedEvents, r as readMatrixMessages, s as EventType, t as deleteMatrixMessage } from "./messages-BRrMlyUc.js";
+import "./runtime-api-D8qG_lUm.js";
+import { t as applyMatrixProfileUpdate } from "./profile-update-DTyqswkt.js";
+import { _ as scanMatrixVerificationQr, a as confirmMatrixVerificationSas, c as getMatrixRoomKeyBackupStatus, d as listMatrixVerifications, f as mismatchMatrixVerificationSas, h as restoreMatrixRoomKeyBackup, i as confirmMatrixVerificationReciprocateQr, l as getMatrixVerificationSas, n as bootstrapMatrixVerification, o as generateMatrixVerificationQr, p as requestMatrixVerification, r as cancelMatrixVerification, s as getMatrixEncryptionStatus, t as acceptMatrixVerification, u as getMatrixVerificationStatus, v as startMatrixVerification, y as verifyMatrixRecoveryKey } from "./verification-DAcx8otJ.js";
+//#region extensions/matrix/src/matrix/actions/polls.ts
+function normalizeOptionIndexes(indexes) {
+	const normalized = indexes.map((index) => Math.trunc(index)).filter((index) => Number.isFinite(index) && index > 0);
+	return Array.from(new Set(normalized));
+}
+function normalizeOptionIds(optionIds) {
+	return Array.from(new Set(optionIds.map((optionId) => optionId.trim()).filter((optionId) => optionId.length > 0)));
+}
+function resolveSelectedAnswerIds(params) {
+	const parsed = parsePollStart(params.pollContent);
+	if (!parsed) throw new Error("Matrix poll vote requires a valid poll start event.");
+	const selectedById = normalizeOptionIds(params.optionIds ?? []);
+	const selectedByIndex = normalizeOptionIndexes(params.optionIndexes ?? []).map((index) => {
+		const answer = parsed.answers[index - 1];
+		if (!answer) throw new Error(`Matrix poll option index ${index} is out of range for a poll with ${parsed.answers.length} options.`);
+		return answer.id;
+	});
+	const answerIds = normalizeOptionIds([...selectedById, ...selectedByIndex]);
+	if (answerIds.length === 0) throw new Error("Matrix poll vote requires at least one poll option id or index.");
+	if (answerIds.length > parsed.maxSelections) throw new Error(`Matrix poll allows at most ${parsed.maxSelections} selection${parsed.maxSelections === 1 ? "" : "s"}.`);
+	const answerMap = new Map(parsed.answers.map((answer) => [answer.id, answer.text]));
+	return {
+		answerIds,
+		labels: answerIds.map((answerId) => {
+			const label = answerMap.get(answerId);
+			if (!label) throw new Error(`Matrix poll option id "${answerId}" is not valid for poll ${parsed.question}.`);
+			return label;
+		}),
+		maxSelections: parsed.maxSelections
+	};
+}
+async function voteMatrixPoll(roomId, pollId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const pollEvent = await client.getEvent(resolvedRoom, pollId);
+		if (!isPollStartType(typeof pollEvent.type === "string" ? pollEvent.type : "")) throw new Error(`Event ${pollId} is not a Matrix poll start event.`);
+		const { answerIds, labels, maxSelections } = resolveSelectedAnswerIds({
+			optionIds: [...opts.optionIds ?? [], ...opts.optionId ? [opts.optionId] : []],
+			optionIndexes: [...opts.optionIndexes ?? [], ...opts.optionIndex !== void 0 ? [opts.optionIndex] : []],
+			pollContent: pollEvent.content
+		});
+		const content = buildPollResponseContent(pollId, answerIds);
+		return {
+			eventId: await client.sendEvent(resolvedRoom, "m.poll.response", content) ?? null,
+			roomId: resolvedRoom,
+			pollId,
+			answerIds,
+			labels,
+			maxSelections
+		};
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/reactions.ts
+async function listMatrixReactionEvents(client, roomId, messageId, limit) {
+	const res = await client.doRequest("GET", buildMatrixReactionRelationsPath(roomId, messageId), {
+		dir: "b",
+		limit
+	});
+	return Array.isArray(res.chunk) ? res.chunk : [];
+}
+async function listMatrixReactions(roomId, messageId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		return summarizeMatrixReactionEvents(await listMatrixReactionEvents(client, resolvedRoom, messageId, resolveMatrixActionLimit(opts.limit, 100)));
+	});
+}
+async function removeMatrixReactions(roomId, messageId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const chunk = await listMatrixReactionEvents(client, resolvedRoom, messageId, 200);
+		const userId = await client.getUserId();
+		if (!userId) return { removed: 0 };
+		const toRemove = selectOwnMatrixReactionEventIds(chunk, userId, opts.emoji);
+		if (toRemove.length === 0) return { removed: 0 };
+		await Promise.all(toRemove.map((id) => client.redactEvent(resolvedRoom, id)));
+		return { removed: toRemove.length };
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/pins.ts
+async function updateMatrixPins(roomId, opts, update) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const next = update(await readPinnedEvents(client, resolvedRoom));
+		const payload = { pinned: next };
+		await client.sendStateEvent(resolvedRoom, EventType.RoomPinnedEvents, "", payload);
+		return { pinned: next };
+	});
+}
+async function pinMatrixMessage(roomId, messageId, opts = {}) {
+	return await updateMatrixPins(roomId, opts, (current) => current.includes(messageId) ? current : [...current, messageId]);
+}
+async function unpinMatrixMessage(roomId, messageId, opts = {}) {
+	return await updateMatrixPins(roomId, opts, (current) => current.filter((id) => id !== messageId));
+}
+async function listMatrixPins(roomId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		const pinned = await readPinnedEvents(client, resolvedRoom);
+		return {
+			pinned,
+			events: (await Promise.all(pinned.map(async (eventId) => {
+				try {
+					return await fetchEventSummary(client, resolvedRoom, eventId);
+				} catch {
+					return null;
+				}
+			}))).filter((event) => Boolean(event))
+		};
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/actions/room.ts
+async function getMatrixMemberInfo(userId, opts = {}) {
+	return await withResolvedActionClient(opts, async (client) => {
+		const roomId = opts.roomId ? await resolveMatrixRoomId(client, opts.roomId) : void 0;
+		const profile = await client.getUserProfile(userId);
+		return {
+			userId,
+			profile: {
+				displayName: profile?.displayname ?? null,
+				avatarUrl: profile?.avatar_url ?? null
+			},
+			membership: null,
+			powerLevel: null,
+			displayName: profile?.displayname ?? null,
+			roomId: roomId ?? null
+		};
+	});
+}
+async function getMatrixRoomInfo(roomId, opts = {}) {
+	return await withResolvedRoomAction(roomId, opts, async (client, resolvedRoom) => {
+		let name = null;
+		let topic = null;
+		let canonicalAlias = null;
+		let memberCount = null;
+		try {
+			const nameState = await client.getRoomStateEvent(resolvedRoom, "m.room.name", "");
+			name = typeof nameState?.name === "string" ? nameState.name : null;
+		} catch {}
+		try {
+			const topicState = await client.getRoomStateEvent(resolvedRoom, EventType.RoomTopic, "");
+			topic = typeof topicState?.topic === "string" ? topicState.topic : null;
+		} catch {}
+		try {
+			const aliasState = await client.getRoomStateEvent(resolvedRoom, "m.room.canonical_alias", "");
+			canonicalAlias = typeof aliasState?.alias === "string" ? aliasState.alias : null;
+		} catch {}
+		try {
+			memberCount = (await client.getJoinedRoomMembers(resolvedRoom)).length;
+		} catch {}
+		return {
+			roomId: resolvedRoom,
+			name,
+			topic,
+			canonicalAlias,
+			altAliases: [],
+			memberCount
+		};
+	});
+}
+//#endregion
+//#region extensions/matrix/src/tool-actions.ts
+const messageActions = new Set([
+	"sendMessage",
+	"editMessage",
+	"deleteMessage",
+	"readMessages"
+]);
+const reactionActions = new Set(["react", "reactions"]);
+const pinActions = new Set([
+	"pinMessage",
+	"unpinMessage",
+	"listPins"
+]);
+const pollActions = new Set(["pollVote"]);
+const profileActions = new Set(["setProfile"]);
+const verificationActions = new Set([
+	"encryptionStatus",
+	"verificationList",
+	"verificationRequest",
+	"verificationAccept",
+	"verificationCancel",
+	"verificationStart",
+	"verificationGenerateQr",
+	"verificationScanQr",
+	"verificationSas",
+	"verificationConfirm",
+	"verificationMismatch",
+	"verificationConfirmQr",
+	"verificationStatus",
+	"verificationBootstrap",
+	"verificationRecoveryKey",
+	"verificationBackupStatus",
+	"verificationBackupRestore"
+]);
+function readRoomId(params, required = true) {
+	const direct = readStringParam(params, "roomId") ?? readStringParam(params, "channelId");
+	if (direct) return direct;
+	if (!required) return readStringParam(params, "to") ?? "";
+	return readStringParam(params, "to", { required: true });
+}
+function toSnakeCaseKey(key) {
+	return normalizeOptionalLowercaseString(key.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2"));
+}
+function readRawParam(params, key) {
+	if (Object.hasOwn(params, key)) return params[key];
+	const snakeKey = toSnakeCaseKey(key);
+	if (snakeKey !== key && Object.hasOwn(params, snakeKey)) return params[snakeKey];
+}
+function readStringAliasParam(params, keys, options = {}) {
+	for (const key of keys) {
+		const raw = readRawParam(params, key);
+		if (typeof raw !== "string") continue;
+		const trimmed = raw.trim();
+		if (trimmed) return trimmed;
+	}
+	if (options.required) throw new Error(`${keys[0]} required`);
+}
+function readNumericArrayParam(params, key, options = {}) {
+	const { integer = false } = options;
+	const raw = readRawParam(params, key);
+	if (raw === void 0) return [];
+	return (Array.isArray(raw) ? raw : [raw]).map((value) => {
+		if (typeof value === "number" && Number.isFinite(value)) return value;
+		if (typeof value === "string") {
+			const trimmed = value.trim();
+			if (!trimmed) return null;
+			const parsed = Number(trimmed);
+			return Number.isFinite(parsed) ? parsed : null;
+		}
+		return null;
+	}).filter((value) => value !== null).map((value) => integer ? Math.trunc(value) : value);
+}
+async function handleMatrixAction(params, cfg, opts = {}) {
+	const action = readStringParam(params, "action", { required: true });
+	const accountId = readStringParam(params, "accountId") ?? void 0;
+	const isActionEnabled = createActionGate(resolveMatrixAccountConfig({
+		cfg,
+		accountId
+	}).actions);
+	const clientOpts = {
+		cfg,
+		...accountId ? { accountId } : {}
+	};
+	if (reactionActions.has(action)) {
+		if (!isActionEnabled("reactions")) throw new Error("Matrix reactions are disabled.");
+		const roomId = readRoomId(params);
+		const messageId = readStringParam(params, "messageId", { required: true });
+		if (action === "react") {
+			const { emoji, remove, isEmpty } = readReactionParams(params, { removeErrorMessage: "Emoji is required to remove a Matrix reaction." });
+			if (remove || isEmpty) return jsonResult({
+				ok: true,
+				removed: (await removeMatrixReactions(roomId, messageId, {
+					...clientOpts,
+					emoji: remove ? emoji : void 0
+				})).removed
+			});
+			await reactMatrixMessage(roomId, messageId, emoji, clientOpts);
+			return jsonResult({
+				ok: true,
+				added: emoji
+			});
+		}
+		const limit = readNumberParam(params, "limit", { integer: true });
+		return jsonResult({
+			ok: true,
+			reactions: await listMatrixReactions(roomId, messageId, {
+				...clientOpts,
+				limit: limit ?? void 0
+			})
+		});
+	}
+	if (pollActions.has(action)) {
+		const roomId = readRoomId(params);
+		const pollId = readStringAliasParam(params, ["pollId", "messageId"], { required: true });
+		if (!pollId) throw new Error("pollId required");
+		const optionId = readStringParam(params, "pollOptionId");
+		const optionIndex = readNumberParam(params, "pollOptionIndex", { integer: true });
+		const optionIds = [...readStringArrayParam(params, "pollOptionIds") ?? [], ...optionId ? [optionId] : []];
+		const optionIndexes = [...readNumericArrayParam(params, "pollOptionIndexes", { integer: true }), ...optionIndex !== void 0 ? [optionIndex] : []];
+		return jsonResult({
+			ok: true,
+			result: await voteMatrixPoll(roomId, pollId, {
+				...clientOpts,
+				optionIds,
+				optionIndexes
+			})
+		});
+	}
+	if (messageActions.has(action)) {
+		if (!isActionEnabled("messages")) throw new Error("Matrix messages are disabled.");
+		switch (action) {
+			case "sendMessage": {
+				const to = readStringParam(params, "to", { required: true });
+				const mediaUrl = readStringParam(params, "mediaUrl", { trim: false }) ?? readStringParam(params, "media", { trim: false }) ?? readStringParam(params, "filePath", { trim: false }) ?? readStringParam(params, "path", { trim: false });
+				const content = readStringParam(params, "content", {
+					required: !mediaUrl,
+					allowEmpty: true
+				});
+				const replyToId = readStringParam(params, "replyToId") ?? readStringParam(params, "replyTo");
+				const threadId = readStringParam(params, "threadId");
+				const audioAsVoice = typeof readRawParam(params, "audioAsVoice") === "boolean" ? readRawParam(params, "audioAsVoice") : typeof readRawParam(params, "asVoice") === "boolean" ? readRawParam(params, "asVoice") : void 0;
+				return jsonResult({
+					ok: true,
+					result: await sendMatrixMessage(to, content, {
+						mediaUrl: mediaUrl ?? void 0,
+						mediaLocalRoots: opts.mediaLocalRoots,
+						replyToId: replyToId ?? void 0,
+						threadId: threadId ?? void 0,
+						audioAsVoice,
+						...clientOpts
+					})
+				});
+			}
+			case "editMessage": return jsonResult({
+				ok: true,
+				result: await editMatrixMessage(readRoomId(params), readStringParam(params, "messageId", { required: true }), readStringParam(params, "content", { required: true }), clientOpts)
+			});
+			case "deleteMessage":
+				await deleteMatrixMessage(readRoomId(params), readStringParam(params, "messageId", { required: true }), {
+					reason: readStringParam(params, "reason") ?? void 0,
+					...clientOpts
+				});
+				return jsonResult({
+					ok: true,
+					deleted: true
+				});
+			case "readMessages": {
+				const roomId = readRoomId(params);
+				const limit = readNumberParam(params, "limit", { integer: true });
+				const before = readStringParam(params, "before");
+				const after = readStringParam(params, "after");
+				return jsonResult({
+					ok: true,
+					...await readMatrixMessages(roomId, {
+						limit: limit ?? void 0,
+						before: before ?? void 0,
+						after: after ?? void 0,
+						...clientOpts
+					})
+				});
+			}
+			default: break;
+		}
+	}
+	if (pinActions.has(action)) {
+		if (!isActionEnabled("pins")) throw new Error("Matrix pins are disabled.");
+		const roomId = readRoomId(params);
+		if (action === "pinMessage") return jsonResult({
+			ok: true,
+			pinned: (await pinMatrixMessage(roomId, readStringParam(params, "messageId", { required: true }), clientOpts)).pinned
+		});
+		if (action === "unpinMessage") return jsonResult({
+			ok: true,
+			pinned: (await unpinMatrixMessage(roomId, readStringParam(params, "messageId", { required: true }), clientOpts)).pinned
+		});
+		const result = await listMatrixPins(roomId, clientOpts);
+		return jsonResult({
+			ok: true,
+			pinned: result.pinned,
+			events: result.events
+		});
+	}
+	if (profileActions.has(action)) {
+		if (!isActionEnabled("profile")) throw new Error("Matrix profile updates are disabled.");
+		const avatarPath = readStringParam(params, "avatarPath") ?? readStringParam(params, "path") ?? readStringParam(params, "filePath");
+		return jsonResult({
+			ok: true,
+			...await applyMatrixProfileUpdate({
+				cfg,
+				account: accountId,
+				displayName: readStringParam(params, "displayName") ?? readStringParam(params, "name"),
+				avatarUrl: readStringParam(params, "avatarUrl"),
+				avatarPath,
+				mediaLocalRoots: opts.mediaLocalRoots
+			})
+		});
+	}
+	if (action === "memberInfo") {
+		if (!isActionEnabled("memberInfo")) throw new Error("Matrix member info is disabled.");
+		return jsonResult({
+			ok: true,
+			member: await getMatrixMemberInfo(readStringParam(params, "userId", { required: true }), {
+				roomId: readStringParam(params, "roomId") ?? readStringParam(params, "channelId") ?? void 0,
+				...clientOpts
+			})
+		});
+	}
+	if (action === "channelInfo") {
+		if (!isActionEnabled("channelInfo")) throw new Error("Matrix room info is disabled.");
+		return jsonResult({
+			ok: true,
+			room: await getMatrixRoomInfo(readRoomId(params), clientOpts)
+		});
+	}
+	if (verificationActions.has(action)) {
+		if (!isActionEnabled("verification")) throw new Error("Matrix verification actions are disabled.");
+		const requestId = readStringParam(params, "requestId") ?? readStringParam(params, "verificationId") ?? readStringParam(params, "id");
+		if (action === "encryptionStatus") return jsonResult({
+			ok: true,
+			status: await getMatrixEncryptionStatus({
+				includeRecoveryKey: params.includeRecoveryKey === true,
+				...clientOpts
+			})
+		});
+		if (action === "verificationStatus") return jsonResult({
+			ok: true,
+			status: await getMatrixVerificationStatus({
+				includeRecoveryKey: params.includeRecoveryKey === true,
+				...clientOpts
+			})
+		});
+		if (action === "verificationBootstrap") {
+			const result = await bootstrapMatrixVerification({
+				recoveryKey: readStringParam(params, "recoveryKey", { trim: false }) ?? readStringParam(params, "key", { trim: false }) ?? void 0,
+				forceResetCrossSigning: params.forceResetCrossSigning === true,
+				...clientOpts
+			});
+			return jsonResult({
+				ok: result.success,
+				result
+			});
+		}
+		if (action === "verificationRecoveryKey") {
+			const result = await verifyMatrixRecoveryKey(readStringParam({ recoveryKey: readStringParam(params, "recoveryKey", { trim: false }) ?? readStringParam(params, "key", { trim: false }) }, "recoveryKey", {
+				required: true,
+				trim: false
+			}), clientOpts);
+			return jsonResult({
+				ok: result.success,
+				result
+			});
+		}
+		if (action === "verificationBackupStatus") return jsonResult({
+			ok: true,
+			status: await getMatrixRoomKeyBackupStatus(clientOpts)
+		});
+		if (action === "verificationBackupRestore") {
+			const result = await restoreMatrixRoomKeyBackup({
+				recoveryKey: readStringParam(params, "recoveryKey", { trim: false }) ?? readStringParam(params, "key", { trim: false }) ?? void 0,
+				...clientOpts
+			});
+			return jsonResult({
+				ok: result.success,
+				result
+			});
+		}
+		if (action === "verificationList") return jsonResult({
+			ok: true,
+			verifications: await listMatrixVerifications(clientOpts)
+		});
+		if (action === "verificationRequest") {
+			const userId = readStringParam(params, "userId");
+			const deviceId = readStringParam(params, "deviceId");
+			const roomId = readStringParam(params, "roomId") ?? readStringParam(params, "channelId");
+			return jsonResult({
+				ok: true,
+				verification: await requestMatrixVerification({
+					ownUser: typeof params.ownUser === "boolean" ? params.ownUser : void 0,
+					userId: userId ?? void 0,
+					deviceId: deviceId ?? void 0,
+					roomId: roomId ?? void 0,
+					...clientOpts
+				})
+			});
+		}
+		if (action === "verificationAccept") return jsonResult({
+			ok: true,
+			verification: await acceptMatrixVerification(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+		if (action === "verificationCancel") {
+			const reason = readStringParam(params, "reason");
+			const code = readStringParam(params, "code");
+			return jsonResult({
+				ok: true,
+				verification: await cancelMatrixVerification(readStringParam({ requestId }, "requestId", { required: true }), {
+					reason: reason ?? void 0,
+					code: code ?? void 0,
+					...clientOpts
+				})
+			});
+		}
+		if (action === "verificationStart") {
+			const method = normalizeOptionalLowercaseString(readStringParam(params, "method"));
+			if (method && method !== "sas") throw new Error("Matrix verificationStart only supports method=sas; use verificationGenerateQr/verificationScanQr for QR flows.");
+			return jsonResult({
+				ok: true,
+				verification: await startMatrixVerification(readStringParam({ requestId }, "requestId", { required: true }), {
+					method: "sas",
+					...clientOpts
+				})
+			});
+		}
+		if (action === "verificationGenerateQr") return jsonResult({
+			ok: true,
+			...await generateMatrixVerificationQr(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+		if (action === "verificationScanQr") {
+			const qrDataBase64 = readStringParam(params, "qrDataBase64") ?? readStringParam(params, "qrData") ?? readStringParam(params, "qr");
+			return jsonResult({
+				ok: true,
+				verification: await scanMatrixVerificationQr(readStringParam({ requestId }, "requestId", { required: true }), readStringParam({ qrDataBase64 }, "qrDataBase64", { required: true }), clientOpts)
+			});
+		}
+		if (action === "verificationSas") return jsonResult({
+			ok: true,
+			sas: await getMatrixVerificationSas(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+		if (action === "verificationConfirm") return jsonResult({
+			ok: true,
+			verification: await confirmMatrixVerificationSas(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+		if (action === "verificationMismatch") return jsonResult({
+			ok: true,
+			verification: await mismatchMatrixVerificationSas(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+		if (action === "verificationConfirmQr") return jsonResult({
+			ok: true,
+			verification: await confirmMatrixVerificationReciprocateQr(readStringParam({ requestId }, "requestId", { required: true }), clientOpts)
+		});
+	}
+	throw new Error(`Unsupported Matrix action: ${action}`);
+}
+//#endregion
+export { handleMatrixAction };

package/dist/tool-actions.runtime.js

@@ -1 +1 @@
-export * from "./tool-actions.runtime-D-h5PI_m.js";
+export * from "./tool-actions.runtime-oUUrD8HB.js";