@kodelyth/discord 2026.5.39 → 2026.6.1

package/dist/channel-actions-BxEBnEuv.js

@@ -0,0 +1,173 @@
+import { r as listDiscordAccountIds, t as createDiscordActionGate } from "./accounts-B7OBFePq.js";
+import { t as inspectDiscordAccount } from "./account-inspect-Dqw-enky.js";
+import { d as readDiscordComponentSpec } from "./components-luonoe13.js";
+import { i as withDiscordInboundEventDeliveryMetadata } from "./inbound-event-delivery-C-1Ji3WP.js";
+import { normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+import { createUnionActionGate } from "klaw/plugin-sdk/channel-actions";
+import { extractToolSend } from "klaw/plugin-sdk/tool-send";
+//#region extensions/discord/src/channel-actions.ts
+let discordChannelActionsRuntimePromise;
+async function loadDiscordChannelActionsRuntime() {
+	discordChannelActionsRuntimePromise ??= import("./channel-actions.runtime-CPtpH-yl.js");
+	return await discordChannelActionsRuntimePromise;
+}
+function listDiscoverableDiscordAccounts(cfg) {
+	return listDiscordAccountIds(cfg).map((accountId) => inspectDiscordAccount({
+		cfg,
+		accountId
+	})).filter((account) => account.enabled && account.configured);
+}
+function resolveDiscordActionDiscovery(cfg) {
+	const accounts = listDiscoverableDiscordAccounts(cfg);
+	if (accounts.length === 0) return null;
+	const unionGate = createUnionActionGate(accounts, (account) => createDiscordActionGate({
+		cfg,
+		accountId: account.accountId
+	}));
+	return { isEnabled: (key, defaultValue = true) => unionGate(key, defaultValue) };
+}
+function resolveScopedDiscordActionDiscovery(params) {
+	if (!params.accountId) return resolveDiscordActionDiscovery(params.cfg);
+	const account = inspectDiscordAccount({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	if (!account.enabled || !account.configured) return null;
+	const gate = createDiscordActionGate({
+		cfg: params.cfg,
+		accountId: account.accountId
+	});
+	return { isEnabled: (key, defaultValue = true) => gate(key, defaultValue) };
+}
+function describeDiscordMessageTool({ cfg, accountId }) {
+	const discovery = resolveScopedDiscordActionDiscovery({
+		cfg,
+		accountId
+	});
+	if (!discovery) return {
+		actions: [],
+		capabilities: [],
+		schema: null
+	};
+	const actions = new Set(["send"]);
+	if (discovery.isEnabled("polls")) actions.add("poll");
+	if (discovery.isEnabled("reactions")) {
+		actions.add("react");
+		actions.add("reactions");
+		actions.add("emoji-list");
+	}
+	if (discovery.isEnabled("messages")) {
+		actions.add("upload-file");
+		actions.add("read");
+		actions.add("edit");
+		actions.add("delete");
+	}
+	if (discovery.isEnabled("pins")) {
+		actions.add("pin");
+		actions.add("unpin");
+		actions.add("list-pins");
+	}
+	if (discovery.isEnabled("permissions")) actions.add("permissions");
+	if (discovery.isEnabled("threads")) {
+		actions.add("thread-create");
+		actions.add("thread-list");
+		actions.add("thread-reply");
+	}
+	if (discovery.isEnabled("search")) actions.add("search");
+	if (discovery.isEnabled("stickers")) actions.add("sticker");
+	if (discovery.isEnabled("memberInfo")) actions.add("member-info");
+	if (discovery.isEnabled("roleInfo")) actions.add("role-info");
+	if (discovery.isEnabled("emojiUploads")) actions.add("emoji-upload");
+	if (discovery.isEnabled("stickerUploads")) actions.add("sticker-upload");
+	if (discovery.isEnabled("roles", false)) {
+		actions.add("role-add");
+		actions.add("role-remove");
+	}
+	if (discovery.isEnabled("channelInfo")) {
+		actions.add("channel-info");
+		actions.add("channel-list");
+	}
+	if (discovery.isEnabled("channels")) {
+		actions.add("channel-create");
+		actions.add("channel-edit");
+		actions.add("channel-delete");
+		actions.add("channel-move");
+		actions.add("category-create");
+		actions.add("category-edit");
+		actions.add("category-delete");
+	}
+	if (discovery.isEnabled("voiceStatus")) actions.add("voice-status");
+	if (discovery.isEnabled("events")) {
+		actions.add("event-list");
+		actions.add("event-create");
+	}
+	if (discovery.isEnabled("moderation", false)) {
+		actions.add("timeout");
+		actions.add("kick");
+		actions.add("ban");
+	}
+	if (discovery.isEnabled("presence", false)) actions.add("set-presence");
+	return {
+		actions: Array.from(actions),
+		capabilities: ["presentation"]
+	};
+}
+const discordMessageActions = {
+	resolveExecutionMode: ({ action }) => action === "read" || action === "search" ? "gateway" : "local",
+	describeMessageTool: describeDiscordMessageTool,
+	extractToolSend: ({ args }) => {
+		const action = normalizeOptionalString(args.action) ?? "";
+		if (action === "sendMessage") return extractToolSend(args, "sendMessage");
+		if (action === "threadReply") {
+			const channelId = normalizeOptionalString(args.channelId) ?? "";
+			return channelId ? { to: `channel:${channelId}` } : null;
+		}
+		return null;
+	},
+	prepareSendPayload: ({ ctx, payload }) => {
+		if (ctx.action !== "send") return null;
+		const payloadWithDeliveryMetadata = withDiscordInboundEventDeliveryMetadata(payload, {
+			sessionKey: ctx.sessionKey,
+			inboundEventKind: ctx.inboundEventKind
+		});
+		const rawComponents = ctx.params.components;
+		if (typeof rawComponents === "function") return null;
+		const componentSpec = rawComponents && typeof rawComponents === "object" && !Array.isArray(rawComponents) ? readDiscordComponentSpec(rawComponents) : void 0;
+		const nativeComponents = Array.isArray(rawComponents) ? rawComponents : void 0;
+		const embeds = Array.isArray(ctx.params.embeds) ? ctx.params.embeds : void 0;
+		if ((componentSpec || nativeComponents) && embeds?.length) return null;
+		const filename = normalizeOptionalString(ctx.params.filename);
+		if (!componentSpec && !nativeComponents && !embeds?.length && !filename) return payloadWithDeliveryMetadata;
+		const discordData = payloadWithDeliveryMetadata.channelData?.discord && typeof payloadWithDeliveryMetadata.channelData.discord === "object" && !Array.isArray(payloadWithDeliveryMetadata.channelData.discord) ? payloadWithDeliveryMetadata.channelData.discord : {};
+		return {
+			...payloadWithDeliveryMetadata,
+			channelData: {
+				...payloadWithDeliveryMetadata.channelData,
+				discord: {
+					...discordData,
+					...componentSpec ? { components: componentSpec } : {},
+					...nativeComponents ? { components: nativeComponents } : {},
+					...embeds?.length ? { embeds } : {},
+					...filename ? { filename } : {}
+				}
+			}
+		};
+	},
+	handleAction: async ({ action, params, cfg, accountId, requesterSenderId, toolContext, mediaAccess, mediaLocalRoots, mediaReadFile, sessionKey, inboundEventKind }) => {
+		return await (await loadDiscordChannelActionsRuntime()).handleDiscordMessageAction({
+			action,
+			params,
+			cfg,
+			accountId,
+			requesterSenderId,
+			toolContext,
+			mediaAccess,
+			mediaLocalRoots,
+			mediaReadFile,
+			...sessionKey ? { sessionKey } : {},
+			...inboundEventKind ? { inboundEventKind } : {}
+		});
+	}
+};
+//#endregion
+export { discordMessageActions as t };

package/dist/channel-actions.runtime-CPtpH-yl.js

@@ -0,0 +1,263 @@
+import { Ut as resolveDiscordChannelId } from "./send.receipt-CDn3GBWC.js";
+import { i as buildDiscordPresentationComponents, r as buildDiscordInteractiveComponents } from "./components-luonoe13.js";
+import { t as handleDiscordAction } from "./runtime-DUaw66V_.js";
+import "./targets-DWLLZE2l.js";
+import "./action-runtime-api.js";
+import { r as notifyDiscordInboundEventOutboundSuccess } from "./inbound-event-delivery-C-1Ji3WP.js";
+import { t as tryHandleDiscordMessageActionGuildAdmin } from "./handle-action.guild-admin-B5BArS2n.js";
+import { normalizeOptionalStringifiedId } from "klaw/plugin-sdk/string-coerce-runtime";
+import { resolveReactionMessageId } from "klaw/plugin-sdk/channel-actions";
+import { readBooleanParam } from "klaw/plugin-sdk/boolean-param";
+import { normalizeInteractiveReply, normalizeMessagePresentation } from "klaw/plugin-sdk/interactive-runtime";
+import { readNumberParam, readStringArrayParam, readStringParam } from "klaw/plugin-sdk/agent-runtime";
+//#region extensions/discord/src/actions/handle-action.ts
+const providerId = "discord";
+function readCurrentDiscordTarget(toolContext) {
+	const provider = toolContext?.currentChannelProvider?.trim().toLowerCase();
+	if (provider && provider !== providerId) return;
+	return toolContext?.currentChannelId?.trim() || void 0;
+}
+async function handleDiscordMessageAction(ctx) {
+	const { action, params, cfg } = ctx;
+	const accountId = ctx.accountId ?? readStringParam(params, "accountId");
+	const actionOptions = {
+		mediaAccess: ctx.mediaAccess,
+		mediaLocalRoots: ctx.mediaLocalRoots,
+		mediaReadFile: ctx.mediaReadFile
+	};
+	const notifyVisibleOutbound = (to, fallbackSessionKey) => notifyDiscordInboundEventOutboundSuccess({
+		sessionKey: ctx.sessionKey ?? fallbackSessionKey ?? void 0,
+		to,
+		accountId,
+		inboundEventKind: ctx.inboundEventKind
+	});
+	const readTarget = () => {
+		const target = readStringParam(params, "channelId") ?? readStringParam(params, "to") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	const resolveChannelId = () => resolveDiscordChannelId(readTarget());
+	const readSendTarget = () => {
+		const target = readStringParam(params, "to") ?? readStringParam(params, "target") ?? readCurrentDiscordTarget(ctx.toolContext);
+		if (!target) throw new Error("Discord channel target is required (use channel:<id>).");
+		return target;
+	};
+	if (action === "send") {
+		const to = readSendTarget();
+		const asVoice = readBooleanParam(params, "asVoice") === true;
+		const rawComponents = params.components ?? buildDiscordPresentationComponents(normalizeMessagePresentation(params.presentation)) ?? buildDiscordInteractiveComponents(normalizeInteractiveReply(params.interactive));
+		const hasComponents = Boolean(rawComponents) && (typeof rawComponents === "function" || typeof rawComponents === "object");
+		const components = hasComponents ? rawComponents : void 0;
+		const mediaUrl = readStringParam(params, "media", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "filePath", { trim: false });
+		const content = readStringParam(params, "message", {
+			required: !asVoice && !hasComponents && !mediaUrl,
+			allowEmpty: true
+		});
+		const filename = readStringParam(params, "filename");
+		const replyTo = readStringParam(params, "replyTo");
+		const rawEmbeds = params.embeds;
+		const embeds = Array.isArray(rawEmbeds) ? rawEmbeds : void 0;
+		const silent = readBooleanParam(params, "silent") === true;
+		const suppressEmbeds = readBooleanParam(params, "suppressEmbeds");
+		const sessionKey = readStringParam(params, "__sessionKey");
+		const agentId = readStringParam(params, "__agentId");
+		const threadName = readStringParam(params, "threadName");
+		const result = await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: content ?? "",
+			...threadName ? { threadName } : {},
+			mediaUrl: mediaUrl ?? void 0,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			components,
+			embeds,
+			asVoice,
+			silent,
+			...suppressEmbeds === void 0 ? {} : { suppressEmbeds },
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(to, sessionKey);
+		return result;
+	}
+	if (action === "upload-file") {
+		const to = readSendTarget();
+		const mediaUrl = readStringParam(params, "filePath", { trim: false }) ?? readStringParam(params, "path", { trim: false }) ?? readStringParam(params, "media", { trim: false });
+		if (!mediaUrl) throw new Error("upload-file requires filePath, path, or media.");
+		const content = readStringParam(params, "message", { allowEmpty: true }) ?? readStringParam(params, "content", { allowEmpty: true });
+		const filename = readStringParam(params, "filename");
+		const replyTo = readStringParam(params, "replyTo");
+		const silent = readBooleanParam(params, "silent") === true;
+		const suppressEmbeds = readBooleanParam(params, "suppressEmbeds");
+		const sessionKey = readStringParam(params, "__sessionKey");
+		const agentId = readStringParam(params, "__agentId");
+		const result = await handleDiscordAction({
+			action: "sendMessage",
+			accountId: accountId ?? void 0,
+			to,
+			content: content ?? "",
+			mediaUrl,
+			filename: filename ?? void 0,
+			replyTo: replyTo ?? void 0,
+			silent,
+			...suppressEmbeds === void 0 ? {} : { suppressEmbeds },
+			__sessionKey: sessionKey ?? void 0,
+			__agentId: agentId ?? void 0
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(to, sessionKey);
+		return result;
+	}
+	if (action === "poll") {
+		const to = readStringParam(params, "to", { required: true });
+		const question = readStringParam(params, "pollQuestion", { required: true });
+		const answers = readStringArrayParam(params, "pollOption", { required: true });
+		const allowMultiselect = readBooleanParam(params, "pollMulti");
+		const durationHours = readNumberParam(params, "pollDurationHours", {
+			integer: true,
+			strict: true
+		});
+		const result = await handleDiscordAction({
+			action: "poll",
+			accountId: accountId ?? void 0,
+			to,
+			question,
+			answers,
+			allowMultiselect,
+			durationHours: durationHours ?? void 0,
+			content: readStringParam(params, "message")
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(to);
+		return result;
+	}
+	if (action === "react") {
+		const messageId = normalizeOptionalStringifiedId(resolveReactionMessageId({
+			args: params,
+			toolContext: ctx.toolContext
+		})) ?? "";
+		if (!messageId) throw new Error("messageId required. Provide messageId explicitly or react to the current inbound message.");
+		const emoji = readStringParam(params, "emoji", { allowEmpty: true });
+		const remove = readBooleanParam(params, "remove");
+		return await handleDiscordAction({
+			action: "react",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			emoji,
+			remove
+		}, cfg, actionOptions);
+	}
+	if (action === "reactions") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const limit = readNumberParam(params, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "reactions",
+			accountId: accountId ?? void 0,
+			channelId: readTarget(),
+			messageId,
+			limit
+		}, cfg, actionOptions);
+	}
+	if (action === "read") {
+		const limit = readNumberParam(params, "limit", { integer: true });
+		return await handleDiscordAction({
+			action: "readMessages",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			limit,
+			before: readStringParam(params, "before"),
+			after: readStringParam(params, "after"),
+			around: readStringParam(params, "around")
+		}, cfg, actionOptions);
+	}
+	if (action === "edit") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		const content = readStringParam(params, "message", { required: true });
+		return await handleDiscordAction({
+			action: "editMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId,
+			content
+		}, cfg, actionOptions);
+	}
+	if (action === "delete") {
+		const messageId = readStringParam(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: "deleteMessage",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "pin" || action === "unpin" || action === "list-pins") {
+		const messageId = action === "list-pins" ? void 0 : readStringParam(params, "messageId", { required: true });
+		return await handleDiscordAction({
+			action: action === "pin" ? "pinMessage" : action === "unpin" ? "unpinMessage" : "listPins",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			messageId
+		}, cfg, actionOptions);
+	}
+	if (action === "permissions") return await handleDiscordAction({
+		action: "permissions",
+		accountId: accountId ?? void 0,
+		channelId: resolveChannelId()
+	}, cfg, actionOptions);
+	if (action === "thread-create") {
+		const name = readStringParam(params, "threadName", { required: true });
+		const messageId = readStringParam(params, "messageId");
+		const content = readStringParam(params, "message");
+		const autoArchiveMinutes = readNumberParam(params, "autoArchiveMin", { integer: true });
+		const appliedTags = readStringArrayParam(params, "appliedTags");
+		const result = await handleDiscordAction({
+			action: "threadCreate",
+			accountId: accountId ?? void 0,
+			channelId: resolveChannelId(),
+			name,
+			messageId,
+			content,
+			autoArchiveMinutes,
+			appliedTags: appliedTags ?? void 0
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(resolveChannelId());
+		return result;
+	}
+	if (action === "sticker") {
+		const to = readStringParam(params, "to", { required: true });
+		const stickerIds = readStringArrayParam(params, "stickerId", {
+			required: true,
+			label: "sticker-id"
+		}) ?? [];
+		const result = await handleDiscordAction({
+			action: "sticker",
+			accountId: accountId ?? void 0,
+			to,
+			stickerIds,
+			content: readStringParam(params, "message")
+		}, cfg, actionOptions);
+		notifyVisibleOutbound(to);
+		return result;
+	}
+	if (action === "set-presence") return await handleDiscordAction({
+		action: "setPresence",
+		accountId: accountId ?? void 0,
+		status: readStringParam(params, "status"),
+		activityType: readStringParam(params, "activityType"),
+		activityName: readStringParam(params, "activityName"),
+		activityUrl: readStringParam(params, "activityUrl"),
+		activityState: readStringParam(params, "activityState")
+	}, cfg, actionOptions);
+	const adminResult = await tryHandleDiscordMessageActionGuildAdmin({
+		ctx,
+		resolveChannelId
+	});
+	if (adminResult !== void 0) {
+		if (action === "thread-reply") notifyVisibleOutbound(readStringParam(params, "threadId") ?? readTarget());
+		return adminResult;
+	}
+	throw new Error(`Action ${action} is not supported for provider ${providerId}.`);
+}
+//#endregion
+export { handleDiscordMessageAction };

package/dist/channel-api-BfjklLby.js

@@ -0,0 +1,21 @@
+import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1 } from "klaw/plugin-sdk/account-id";
+import { PAIRING_APPROVED_MESSAGE, buildTokenChannelStatusSummary, projectCredentialSnapshotFields, resolveConfiguredFromCredentialStatuses } from "klaw/plugin-sdk/channel-status";
+//#region extensions/discord/src/channel-api.ts
+const DISCORD_CHANNEL_META = {
+	id: "discord",
+	label: "Discord",
+	selectionLabel: "Discord (Bot API)",
+	detailLabel: "Discord Bot",
+	docsPath: "/channels/discord",
+	docsLabel: "discord",
+	blurb: "very well supported right now.",
+	systemImage: "bubble.left.and.bubble.right",
+	markdownCapable: true,
+	preferSessionLookupForAnnounceTarget: true
+};
+function getChatChannelMeta(id) {
+	if (id !== DISCORD_CHANNEL_META.id) throw new Error(`Unsupported Discord channel meta lookup: ${id}`);
+	return DISCORD_CHANNEL_META;
+}
+//#endregion
+export { projectCredentialSnapshotFields as a, getChatChannelMeta as i, PAIRING_APPROVED_MESSAGE as n, resolveConfiguredFromCredentialStatuses as o, buildTokenChannelStatusSummary as r, DEFAULT_ACCOUNT_ID$1 as t };

package/dist/channel-config-api.js

@@ -0,0 +1,2 @@
+import { t as DiscordChannelConfigSchema } from "./config-schema-DIqJBGwC.js";
+export { DiscordChannelConfigSchema };

package/dist/channel-plugin-api.js

@@ -0,0 +1,2 @@
+import { t as discordPlugin } from "./channel-U_aeoFwW.js";
+export { discordPlugin };