experimental-ash 0.25.1 → 0.26.0

package/dist/src/public/channels/discord/hitl.js

@@ -0,0 +1,194 @@
+/**
+ * Discord HITL component rendering + decode helpers.
+ *
+ * Discord components carry a `custom_id` with a 100-character cap. Ash
+ * encodes only the request id and, for buttons, the selected option id.
+ */
+import { DISCORD_INTERACTION_RESPONSE_TYPE, } from "#public/channels/discord/inbound.js";
+/** Discord component type values used by the native channel. */
+export const DISCORD_COMPONENT_TYPE = {
+    ACTION_ROW: 1,
+    BUTTON: 2,
+    STRING_SELECT: 3,
+    TEXT_INPUT: 4,
+};
+/** Custom id prefix for selectable HITL controls. */
+export const DISCORD_HITL_CUSTOM_ID_PREFIX = "ash_input:";
+/** Custom id prefix for the button/modal freeform flow. */
+export const DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX = "ash_input_freeform:";
+/** Text-input id inside the freeform modal. */
+export const DISCORD_HITL_FREEFORM_TEXT_INPUT_ID = "ash_freeform_text";
+const DISCORD_CUSTOM_ID_MAX_LENGTH = 100;
+const DISCORD_LABEL_MAX_LENGTH = 80;
+const DISCORD_SELECT_OPTION_TEXT_MAX_LENGTH = 100;
+const DISCORD_MODAL_TITLE_MAX_LENGTH = 45;
+const DISCORD_ACTION_ROW_LIMIT = 5;
+const DISCORD_SELECT_OPTION_LIMIT = 25;
+/** Renders one input request as Discord message components. */
+export function renderInputRequestComponents(request) {
+    const options = request.options;
+    const acceptsFreeform = request.allowFreeform === true || !options || options.length === 0;
+    if (options && options.length > 0 && request.display === "select") {
+        return [
+            {
+                components: [
+                    {
+                        custom_id: encodeHitlCustomId(DISCORD_HITL_CUSTOM_ID_PREFIX, {
+                            requestId: request.requestId,
+                        }),
+                        options: options.slice(0, DISCORD_SELECT_OPTION_LIMIT).map((option) => {
+                            const result = {
+                                label: truncate(option.label, DISCORD_SELECT_OPTION_TEXT_MAX_LENGTH),
+                                value: truncate(option.id, DISCORD_SELECT_OPTION_TEXT_MAX_LENGTH),
+                            };
+                            if (option.description !== undefined) {
+                                result.description = truncate(option.description, DISCORD_SELECT_OPTION_TEXT_MAX_LENGTH);
+                            }
+                            return result;
+                        }),
+                        placeholder: "Choose an option",
+                        type: DISCORD_COMPONENT_TYPE.STRING_SELECT,
+                    },
+                ],
+                type: DISCORD_COMPONENT_TYPE.ACTION_ROW,
+            },
+        ];
+    }
+    if (options && options.length > 0) {
+        return chunk(options.slice(0, DISCORD_ACTION_ROW_LIMIT * DISCORD_ACTION_ROW_LIMIT), 5).map((row) => ({
+            components: row.map((option) => ({
+                custom_id: encodeHitlCustomId(DISCORD_HITL_CUSTOM_ID_PREFIX, {
+                    optionId: option.id,
+                    requestId: request.requestId,
+                }),
+                label: truncate(option.label, DISCORD_LABEL_MAX_LENGTH),
+                style: toDiscordButtonStyle(option.style),
+                type: DISCORD_COMPONENT_TYPE.BUTTON,
+            })),
+            type: DISCORD_COMPONENT_TYPE.ACTION_ROW,
+        }));
+    }
+    if (acceptsFreeform) {
+        return [
+            {
+                components: [
+                    {
+                        custom_id: encodeHitlCustomId(DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX, {
+                            requestId: request.requestId,
+                        }),
+                        label: "Type your answer",
+                        style: 1,
+                        type: DISCORD_COMPONENT_TYPE.BUTTON,
+                    },
+                ],
+                type: DISCORD_COMPONENT_TYPE.ACTION_ROW,
+            },
+        ];
+    }
+    return [];
+}
+/** Builds a Discord modal response for one freeform HITL request. */
+export function buildFreeformModalResponse(input) {
+    const payload = decodeHitlCustomId(input.customId, DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX);
+    if (!payload) {
+        throw new Error("discordChannel: freeform custom_id is malformed.");
+    }
+    return {
+        data: {
+            components: [
+                {
+                    components: [
+                        {
+                            custom_id: DISCORD_HITL_FREEFORM_TEXT_INPUT_ID,
+                            label: "Answer",
+                            max_length: 4000,
+                            min_length: 1,
+                            placeholder: "Type your answer here...",
+                            required: true,
+                            style: 2,
+                            type: DISCORD_COMPONENT_TYPE.TEXT_INPUT,
+                        },
+                    ],
+                    type: DISCORD_COMPONENT_TYPE.ACTION_ROW,
+                },
+            ],
+            custom_id: encodeHitlCustomId(DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX, {
+                requestId: payload.requestId,
+            }),
+            title: truncate(input.prompt ?? "Your answer", DISCORD_MODAL_TITLE_MAX_LENGTH),
+        },
+        type: DISCORD_INTERACTION_RESPONSE_TYPE.MODAL,
+    };
+}
+/** Returns true when a component custom id starts the freeform modal flow. */
+export function isDiscordFreeformComponent(customId) {
+    return decodeHitlCustomId(customId, DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX) !== null;
+}
+/** Decodes one component interaction into HITL input responses. */
+export function deriveComponentInputResponses(interaction) {
+    const payload = decodeHitlCustomId(interaction.customId, DISCORD_HITL_CUSTOM_ID_PREFIX);
+    if (!payload)
+        return [];
+    if (payload.optionId !== undefined) {
+        return [{ optionId: payload.optionId, requestId: payload.requestId }];
+    }
+    const selected = interaction.values[0];
+    if (selected !== undefined) {
+        return [{ optionId: selected, requestId: payload.requestId }];
+    }
+    return [];
+}
+/** Decodes one modal submission into HITL input responses. */
+export function deriveModalInputResponses(interaction) {
+    const payload = decodeHitlCustomId(interaction.customId, DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX);
+    const text = interaction.textInputs[DISCORD_HITL_FREEFORM_TEXT_INPUT_ID];
+    if (!payload || text === undefined)
+        return [];
+    return [{ requestId: payload.requestId, text }];
+}
+function encodeHitlCustomId(prefix, payload) {
+    const encoded = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    const customId = `${prefix}${encoded}`;
+    if (customId.length > DISCORD_CUSTOM_ID_MAX_LENGTH) {
+        throw new Error("discordChannel: HITL custom_id exceeded Discord's 100-character limit.");
+    }
+    return customId;
+}
+function decodeHitlCustomId(customId, prefix) {
+    if (!customId.startsWith(prefix))
+        return null;
+    try {
+        const decoded = Buffer.from(customId.slice(prefix.length), "base64url").toString("utf8");
+        const parsed = JSON.parse(decoded);
+        if (typeof parsed.requestId !== "string" || parsed.requestId.length === 0)
+            return null;
+        const result = { requestId: parsed.requestId };
+        if (typeof parsed.optionId === "string") {
+            return { ...result, optionId: parsed.optionId };
+        }
+        return result;
+    }
+    catch {
+        return null;
+    }
+}
+function toDiscordButtonStyle(style) {
+    if (style === "primary")
+        return 1;
+    if (style === "danger")
+        return 4;
+    return 2;
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    const sliceLength = Math.max(0, maxLength - 3);
+    return `${value.slice(0, sliceLength).trimEnd()}...`;
+}
+function chunk(values, size) {
+    const result = [];
+    for (let index = 0; index < values.length; index += size) {
+        result.push(values.slice(index, index + size));
+    }
+    return result;
+}

package/dist/src/public/channels/discord/inbound.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Inbound Discord interaction parsing and prompt shaping.
+ *
+ * The channel owns small, documented data shapes instead of exposing
+ * Discord's raw interaction payloads as the primary public API.
+ */
+import type { UserContent } from "ai";
+/** Discord interaction type values used by the native channel. */
+export declare const DISCORD_INTERACTION_TYPE: {
+    readonly APPLICATION_COMMAND: 2;
+    readonly MESSAGE_COMPONENT: 3;
+    readonly MODAL_SUBMIT: 5;
+    readonly PING: 1;
+};
+/** Discord interaction callback type values used by the native channel. */
+export declare const DISCORD_INTERACTION_RESPONSE_TYPE: {
+    readonly CHANNEL_MESSAGE_WITH_SOURCE: 4;
+    readonly DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE: 5;
+    readonly DEFERRED_UPDATE_MESSAGE: 6;
+    readonly MODAL: 9;
+    readonly PONG: 1;
+};
+/** Discord message flag for ephemeral responses. */
+export declare const DISCORD_EPHEMERAL_MESSAGE_FLAG: number;
+/** Discord user metadata surfaced by inbound interactions. */
+export interface DiscordUser {
+    readonly avatar?: string;
+    readonly discriminator?: string;
+    readonly globalName?: string;
+    readonly id: string;
+    readonly isBot: boolean;
+    readonly username: string;
+}
+/** Discord guild member metadata surfaced by inbound interactions. */
+export interface DiscordMember {
+    readonly nick?: string;
+    readonly roles: readonly string[];
+    readonly user: DiscordUser;
+}
+/** Common fields shared by parsed Discord interactions. */
+export interface DiscordInteractionBase {
+    readonly applicationId: string;
+    readonly channelId: string;
+    readonly guildId?: string;
+    readonly id: string;
+    readonly member?: DiscordMember;
+    readonly token: string;
+    readonly user: DiscordUser;
+    readonly raw: Record<string, unknown>;
+}
+/** One slash-command option from Discord's interaction payload. */
+export interface DiscordCommandOption {
+    readonly name: string;
+    readonly value?: string | number | boolean;
+    readonly options: readonly DiscordCommandOption[];
+}
+/** Parsed Discord slash/application command interaction. */
+export interface DiscordCommandInteraction extends DiscordInteractionBase {
+    readonly commandId?: string;
+    readonly commandName: string;
+    readonly options: readonly DiscordCommandOption[];
+    readonly type: typeof DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND;
+}
+/** Parsed Discord message-component interaction. */
+export interface DiscordComponentInteraction extends DiscordInteractionBase {
+    readonly componentType: number;
+    readonly customId: string;
+    readonly messageId: string;
+    readonly type: typeof DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT;
+    readonly values: readonly string[];
+}
+/** Parsed Discord modal-submit interaction. */
+export interface DiscordModalSubmitInteraction extends DiscordInteractionBase {
+    readonly customId: string;
+    readonly messageId?: string;
+    readonly textInputs: Readonly<Record<string, string>>;
+    readonly type: typeof DISCORD_INTERACTION_TYPE.MODAL_SUBMIT;
+}
+/** Parsed Discord interaction variants handled by the native channel. */
+export type DiscordInteraction = DiscordCommandInteraction | DiscordComponentInteraction | DiscordModalSubmitInteraction;
+/** Inbound context rendered into the model-visible `<discord_context>` block. */
+export interface DiscordInboundContext {
+    readonly channelId: string;
+    readonly commandName?: string;
+    readonly guildId?: string;
+    readonly interactionId: string;
+    readonly userId: string;
+    readonly username?: string;
+}
+/** Parses one JSON-decoded Discord interaction payload. */
+export declare function parseDiscordInteraction(value: unknown): DiscordInteraction | null;
+/** Extracts the model-facing message from one Discord command. */
+export declare function commandInteractionMessage(interaction: DiscordCommandInteraction): string;
+/** Renders one {@link DiscordInboundContext} as a deterministic context block. */
+export declare function formatDiscordContextBlock(context: DiscordInboundContext): string;
+/** Prepends a `<discord_context>` block to the inbound turn message. */
+export declare function prependDiscordContext(message: string | UserContent, context: DiscordInboundContext): string | UserContent;

package/dist/src/public/channels/discord/inbound.js

@@ -0,0 +1,238 @@
+/**
+ * Inbound Discord interaction parsing and prompt shaping.
+ *
+ * The channel owns small, documented data shapes instead of exposing
+ * Discord's raw interaction payloads as the primary public API.
+ */
+import { isNonEmptyString, isObject } from "#shared/guards.js";
+/** Discord interaction type values used by the native channel. */
+export const DISCORD_INTERACTION_TYPE = {
+    APPLICATION_COMMAND: 2,
+    MESSAGE_COMPONENT: 3,
+    MODAL_SUBMIT: 5,
+    PING: 1,
+};
+/** Discord interaction callback type values used by the native channel. */
+export const DISCORD_INTERACTION_RESPONSE_TYPE = {
+    CHANNEL_MESSAGE_WITH_SOURCE: 4,
+    DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE: 5,
+    DEFERRED_UPDATE_MESSAGE: 6,
+    MODAL: 9,
+    PONG: 1,
+};
+/** Discord message flag for ephemeral responses. */
+export const DISCORD_EPHEMERAL_MESSAGE_FLAG = 1 << 6;
+const DISCORD_RESPONSE_INSTRUCTIONS = "Reply for Discord in concise Markdown. Avoid mass mentions, long tables, " +
+    "and messages that need more than a few short posts.";
+/** Parses one JSON-decoded Discord interaction payload. */
+export function parseDiscordInteraction(value) {
+    if (!isObject(value))
+        return null;
+    const type = value.type;
+    if (type === DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND) {
+        return parseCommandInteraction(value);
+    }
+    if (type === DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT) {
+        return parseComponentInteraction(value);
+    }
+    if (type === DISCORD_INTERACTION_TYPE.MODAL_SUBMIT) {
+        return parseModalSubmitInteraction(value);
+    }
+    return null;
+}
+/** Extracts the model-facing message from one Discord command. */
+export function commandInteractionMessage(interaction) {
+    const message = findOptionValue(interaction.options, "message");
+    if (typeof message === "string" && message.trim().length > 0)
+        return message;
+    const optionText = formatCommandOptions(interaction.options);
+    return optionText ? `/${interaction.commandName} ${optionText}` : `/${interaction.commandName}`;
+}
+/** Renders one {@link DiscordInboundContext} as a deterministic context block. */
+export function formatDiscordContextBlock(context) {
+    const lines = [
+        "<discord_context>",
+        "response_medium: discord",
+        `response_instructions: ${DISCORD_RESPONSE_INSTRUCTIONS}`,
+        `user_id: ${context.userId}`,
+        ...(context.username ? [`username: ${context.username}`] : []),
+        `channel_id: ${context.channelId}`,
+        ...(context.guildId ? [`guild_id: ${context.guildId}`] : []),
+        `interaction_id: ${context.interactionId}`,
+        ...(context.commandName ? [`command_name: ${context.commandName}`] : []),
+        "</discord_context>",
+    ];
+    return lines.join("\n");
+}
+/** Prepends a `<discord_context>` block to the inbound turn message. */
+export function prependDiscordContext(message, context) {
+    const block = formatDiscordContextBlock(context);
+    if (typeof message === "string") {
+        return message.length > 0 ? `${block}\n\n${message}` : block;
+    }
+    const contextPart = { type: "text", text: block };
+    return [contextPart, ...message];
+}
+function parseCommandInteraction(raw) {
+    const base = parseInteractionBase(raw);
+    const data = isObject(raw.data) ? raw.data : null;
+    if (!base || !data || !isNonEmptyString(data.name))
+        return null;
+    return {
+        ...base,
+        commandId: isNonEmptyString(data.id) ? data.id : undefined,
+        commandName: data.name,
+        options: parseOptions(data.options),
+        type: DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND,
+    };
+}
+function parseComponentInteraction(raw) {
+    const base = parseInteractionBase(raw);
+    const data = isObject(raw.data) ? raw.data : null;
+    const message = isObject(raw.message) ? raw.message : null;
+    if (!base || !data || !isNonEmptyString(data.custom_id))
+        return null;
+    const messageId = isNonEmptyString(message?.id) ? message.id : "";
+    if (!messageId)
+        return null;
+    return {
+        ...base,
+        componentType: typeof data.component_type === "number" ? data.component_type : 0,
+        customId: data.custom_id,
+        messageId,
+        type: DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT,
+        values: Array.isArray(data.values)
+            ? data.values.filter((entry) => typeof entry === "string")
+            : [],
+    };
+}
+function parseModalSubmitInteraction(raw) {
+    const base = parseInteractionBase(raw);
+    const data = isObject(raw.data) ? raw.data : null;
+    if (!base || !data || !isNonEmptyString(data.custom_id))
+        return null;
+    const message = isObject(raw.message) ? raw.message : null;
+    return {
+        ...base,
+        customId: data.custom_id,
+        messageId: isNonEmptyString(message?.id) ? message.id : undefined,
+        textInputs: parseTextInputs(data.components),
+        type: DISCORD_INTERACTION_TYPE.MODAL_SUBMIT,
+    };
+}
+function parseInteractionBase(raw) {
+    if (!isNonEmptyString(raw.id) ||
+        !isNonEmptyString(raw.application_id) ||
+        !isNonEmptyString(raw.channel_id) ||
+        !isNonEmptyString(raw.token)) {
+        return null;
+    }
+    const user = parseInteractionUser(raw);
+    if (!user)
+        return null;
+    return {
+        applicationId: raw.application_id,
+        channelId: raw.channel_id,
+        guildId: isNonEmptyString(raw.guild_id) ? raw.guild_id : undefined,
+        id: raw.id,
+        member: parseMember(raw.member),
+        raw,
+        token: raw.token,
+        user,
+    };
+}
+function parseInteractionUser(raw) {
+    const directUser = parseUser(raw.user);
+    if (directUser)
+        return directUser;
+    const member = parseMember(raw.member);
+    return member?.user ?? null;
+}
+function parseMember(value) {
+    if (!isObject(value))
+        return undefined;
+    const user = parseUser(value.user);
+    if (!user)
+        return undefined;
+    return {
+        nick: isNonEmptyString(value.nick) ? value.nick : undefined,
+        roles: Array.isArray(value.roles)
+            ? value.roles.filter((entry) => typeof entry === "string")
+            : [],
+        user,
+    };
+}
+function parseUser(value) {
+    if (!isObject(value) || !isNonEmptyString(value.id) || !isNonEmptyString(value.username)) {
+        return null;
+    }
+    return {
+        avatar: isNonEmptyString(value.avatar) ? value.avatar : undefined,
+        discriminator: isNonEmptyString(value.discriminator) ? value.discriminator : undefined,
+        globalName: isNonEmptyString(value.global_name) ? value.global_name : undefined,
+        id: value.id,
+        isBot: value.bot === true,
+        username: value.username,
+    };
+}
+function parseOptions(value) {
+    if (!Array.isArray(value))
+        return [];
+    const options = [];
+    for (const item of value) {
+        if (!isObject(item) || !isNonEmptyString(item.name))
+            continue;
+        const option = {
+            name: item.name,
+            options: parseOptions(item.options),
+            value: parseOptionValue(item.value),
+        };
+        options.push(option);
+    }
+    return options;
+}
+function parseOptionValue(value) {
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        return value;
+    }
+    return undefined;
+}
+function parseTextInputs(value) {
+    const inputs = {};
+    if (!Array.isArray(value))
+        return inputs;
+    for (const row of value) {
+        if (!isObject(row) || !Array.isArray(row.components))
+            continue;
+        for (const component of row.components) {
+            if (!isObject(component))
+                continue;
+            if (isNonEmptyString(component.custom_id) && typeof component.value === "string") {
+                inputs[component.custom_id] = component.value;
+            }
+        }
+    }
+    return inputs;
+}
+function findOptionValue(options, name) {
+    for (const option of options) {
+        if (option.name === name && option.value !== undefined)
+            return option.value;
+        const nested = findOptionValue(option.options, name);
+        if (nested !== undefined)
+            return nested;
+    }
+    return undefined;
+}
+function formatCommandOptions(options) {
+    return options
+        .map(formatOption)
+        .filter((entry) => entry.length > 0)
+        .join(" ");
+}
+function formatOption(option) {
+    if (option.value !== undefined)
+        return `${option.name}:${String(option.value)}`;
+    const nested = formatCommandOptions(option.options);
+    return nested ? `${option.name} ${nested}` : option.name;
+}

package/dist/src/public/channels/discord/index.d.ts

@@ -0,0 +1,7 @@
+export type { ModelMessage } from "ai";
+export { discordChannel, type DiscordChannel, type DiscordChannelConfig, type DiscordChannelCredentials, type DiscordChannelEvents, type DiscordChannelState, type DiscordCommandResult, type DiscordCommandResultOrPromise, type DiscordContext, type DiscordEventContext, type DiscordHandle, type DiscordReceiveArgs, type DiscordRequestOptions, } from "#public/channels/discord/discordChannel.js";
+export { callDiscordApi, createDiscordFollowupMessage, discordContinuationToken, DISCORD_MESSAGE_CONTENT_MAX_LENGTH, DISCORD_NO_MENTIONS, editDiscordOriginalResponse, resolveDiscordApplicationId, resolveDiscordBotToken, resolveDiscordPublicKey, sendDiscordChannelMessage, splitDiscordMessageContent, triggerDiscordTypingIndicator, type DiscordApiOptions, type DiscordApiResponse, type DiscordApplicationId, type DiscordBotToken, type DiscordCredentials, type DiscordFetch, type DiscordMessageBody, type DiscordPostedMessage, } from "#public/channels/discord/api.js";
+export { DISCORD_EPHEMERAL_MESSAGE_FLAG, DISCORD_INTERACTION_RESPONSE_TYPE, DISCORD_INTERACTION_TYPE, commandInteractionMessage, formatDiscordContextBlock, parseDiscordInteraction, prependDiscordContext, type DiscordCommandInteraction, type DiscordCommandOption, type DiscordComponentInteraction, type DiscordInboundContext, type DiscordInteraction, type DiscordInteractionBase, type DiscordMember, type DiscordModalSubmitInteraction, type DiscordUser, } from "#public/channels/discord/inbound.js";
+export { DISCORD_COMPONENT_TYPE, DISCORD_HITL_CUSTOM_ID_PREFIX, DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX, DISCORD_HITL_FREEFORM_TEXT_INPUT_ID, buildFreeformModalResponse, deriveComponentInputResponses, deriveModalInputResponses, isDiscordFreeformComponent, renderInputRequestComponents, } from "#public/channels/discord/hitl.js";
+export { defaultDiscordAuth } from "#public/channels/discord/defaults.js";
+export { verifyDiscordRequest, verifyDiscordSignature, type DiscordPublicKey, type DiscordVerifyOptions, type DiscordWebhookVerifier, } from "#public/channels/discord/verify.js";

package/dist/src/public/channels/discord/index.js

@@ -0,0 +1,6 @@
+export { discordChannel, } from "#public/channels/discord/discordChannel.js";
+export { callDiscordApi, createDiscordFollowupMessage, discordContinuationToken, DISCORD_MESSAGE_CONTENT_MAX_LENGTH, DISCORD_NO_MENTIONS, editDiscordOriginalResponse, resolveDiscordApplicationId, resolveDiscordBotToken, resolveDiscordPublicKey, sendDiscordChannelMessage, splitDiscordMessageContent, triggerDiscordTypingIndicator, } from "#public/channels/discord/api.js";
+export { DISCORD_EPHEMERAL_MESSAGE_FLAG, DISCORD_INTERACTION_RESPONSE_TYPE, DISCORD_INTERACTION_TYPE, commandInteractionMessage, formatDiscordContextBlock, parseDiscordInteraction, prependDiscordContext, } from "#public/channels/discord/inbound.js";
+export { DISCORD_COMPONENT_TYPE, DISCORD_HITL_CUSTOM_ID_PREFIX, DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX, DISCORD_HITL_FREEFORM_TEXT_INPUT_ID, buildFreeformModalResponse, deriveComponentInputResponses, deriveModalInputResponses, isDiscordFreeformComponent, renderInputRequestComponents, } from "#public/channels/discord/hitl.js";
+export { defaultDiscordAuth } from "#public/channels/discord/defaults.js";
+export { verifyDiscordRequest, verifyDiscordSignature, } from "#public/channels/discord/verify.js";

package/dist/src/public/channels/discord/responses.d.ts

@@ -0,0 +1,11 @@
+/** Builds the Discord acknowledgement response for deferred command handling. */
+export declare function discordDeferredJson(ephemeral: boolean): Response;
+/** Builds a Discord interaction callback JSON response. */
+export declare function discordJson(input: {
+    readonly content: string;
+    readonly ephemeral?: boolean;
+} | Record<string, unknown>): Response;
+/** Serializes a Discord interaction callback body. */
+export declare function discordJsonBody(body: Record<string, unknown>): Response;
+/** Reads component or modal source message content from a raw Discord interaction. */
+export declare function readMessageContent(raw: Record<string, unknown>): string | undefined;

package/dist/src/public/channels/discord/responses.js

@@ -0,0 +1,40 @@
+import { DISCORD_EPHEMERAL_MESSAGE_FLAG, DISCORD_INTERACTION_RESPONSE_TYPE, } from "#public/channels/discord/inbound.js";
+import { isNonEmptyString, isObject } from "#shared/guards.js";
+import { parseJsonObject } from "#shared/json.js";
+/** Builds the Discord acknowledgement response for deferred command handling. */
+export function discordDeferredJson(ephemeral) {
+    const body = {
+        type: DISCORD_INTERACTION_RESPONSE_TYPE.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE,
+    };
+    if (ephemeral) {
+        body.data = { flags: DISCORD_EPHEMERAL_MESSAGE_FLAG };
+    }
+    return discordJsonBody(body);
+}
+/** Builds a Discord interaction callback JSON response. */
+export function discordJson(input) {
+    if ("content" in input && typeof input.content === "string") {
+        const data = {
+            allowed_mentions: { parse: [] },
+            content: input.content,
+        };
+        if (input.ephemeral === true)
+            data.flags = DISCORD_EPHEMERAL_MESSAGE_FLAG;
+        return discordJsonBody({
+            data,
+            type: DISCORD_INTERACTION_RESPONSE_TYPE.CHANNEL_MESSAGE_WITH_SOURCE,
+        });
+    }
+    return discordJsonBody(input);
+}
+/** Serializes a Discord interaction callback body. */
+export function discordJsonBody(body) {
+    return Response.json(parseJsonObject(body), {
+        headers: { "content-type": "application/json; charset=utf-8" },
+    });
+}
+/** Reads component or modal source message content from a raw Discord interaction. */
+export function readMessageContent(raw) {
+    const message = isObject(raw.message) ? raw.message : null;
+    return isNonEmptyString(message?.content) ? message.content : undefined;
+}

package/dist/src/public/channels/discord/verify.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Discord inbound-interaction verification.
+ *
+ * Discord signs interaction webhooks with Ed25519. The signed payload is
+ * the `X-Signature-Timestamp` header concatenated with the exact raw
+ * request body string.
+ */
+/** Discord application public key, materialized directly or from an async secret provider. */
+export type DiscordPublicKey = string | (() => string | Promise<string>);
+/**
+ * Caller-supplied inbound webhook verifier. Used as an alternative to
+ * Ed25519 verification when an integration authenticates forwarded
+ * webhooks before they reach Ash.
+ */
+export type DiscordWebhookVerifier = (request: Request, body: string) => unknown | Promise<unknown>;
+/** Options for {@link verifyDiscordRequest}. */
+export interface DiscordVerifyOptions {
+    readonly publicKey: DiscordPublicKey | undefined;
+    readonly webhookVerifier?: DiscordWebhookVerifier;
+    /** Max allowed clock skew, in seconds. Defaults to 5 minutes. */
+    readonly maxSkewSeconds?: number;
+}
+/** Resolves a Discord public key, falling back to `DISCORD_PUBLIC_KEY`. */
+export declare function resolveDiscordPublicKey(publicKey?: DiscordPublicKey): Promise<string>;
+/**
+ * Verifies an inbound Discord interaction request and returns the raw body.
+ *
+ * Throws when no public key/verifier is configured, required signature
+ * headers are missing, timestamp checks fail, or the signature check fails.
+ */
+export declare function verifyDiscordRequest(request: Request, options: DiscordVerifyOptions): Promise<string>;
+/** Verifies one Discord Ed25519 signature. */
+export declare function verifyDiscordSignature(input: {
+    readonly body: string;
+    readonly publicKey: string;
+    readonly signature: string;
+    readonly timestamp: string;
+}): boolean;