eve 0.5.4 → 0.6.0-beta.3

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

@@ -0,0 +1,106 @@
+/**
+ * Minimal Discord REST API wrapper. The channel talks directly to Discord's
+ * JSON HTTP API rather than exposing a third-party SDK through Eve.
+ */
+import { type JsonObject } from "#shared/json.js";
+import { resolveDiscordPublicKey, type DiscordPublicKey } from "#public/channels/discord/verify.js";
+/** Discord application id, materialized directly or from an async secret provider. */
+export type DiscordApplicationId = string | (() => string | Promise<string>);
+/** Discord bot token, materialized directly or from an async secret provider. */
+export type DiscordBotToken = string | (() => string | Promise<string>);
+/** Fetch implementation override used by tests or non-standard runtimes. */
+export type DiscordFetch = typeof fetch;
+/**
+ * Credentials used by the native Discord channel. Each field falls back to the
+ * matching `DISCORD_*` env var when omitted.
+ */
+export interface DiscordCredentials {
+    /** Required to edit or follow up on interaction responses. Falls back to `DISCORD_APPLICATION_ID`. */
+    readonly applicationId?: DiscordApplicationId;
+    /** Required for channel messages and typing indicators. Falls back to `DISCORD_BOT_TOKEN`. */
+    readonly botToken?: DiscordBotToken;
+    /** Required for inbound Ed25519 interaction verification. Falls back to `DISCORD_PUBLIC_KEY`. */
+    readonly publicKey?: DiscordPublicKey;
+}
+/** Shared Discord API options. */
+export interface DiscordApiOptions {
+    readonly apiBaseUrl?: string;
+    readonly credentials?: DiscordCredentials;
+    readonly fetch?: DiscordFetch;
+}
+/** Raw Discord API call result. `body` is parsed JSON, or text/null when not JSON. */
+export interface DiscordApiResponse {
+    readonly status: number;
+    readonly ok: boolean;
+    readonly body: unknown;
+}
+/** Minimal Discord message object returned by channel write operations. */
+export interface DiscordPostedMessage {
+    /** Discord message id, when Discord returned one. */
+    readonly id: string;
+    /** Channel id associated with the message, when Discord returned one. */
+    readonly channelId?: string;
+    /** Discord's raw JSON response. */
+    readonly raw: unknown;
+}
+/** Allowed mentions payload that suppresses all generated pings. */
+export declare const DISCORD_NO_MENTIONS: JsonObject;
+/** Discord's documented message-content cap. */
+export declare const DISCORD_MESSAGE_CONTENT_MAX_LENGTH = 2000;
+/** Builds the channel-local continuation token (`<channelId>:<conversationId>`). */
+export declare function discordContinuationToken(channelId: string, conversationId: string | undefined): string;
+/** Resolves a Discord application id, falling back to `DISCORD_APPLICATION_ID`. */
+export declare function resolveDiscordApplicationId(applicationId?: DiscordApplicationId): Promise<string>;
+/** Resolves a Discord bot token, falling back to `DISCORD_BOT_TOKEN`. */
+export declare function resolveDiscordBotToken(botToken?: DiscordBotToken): Promise<string>;
+export { resolveDiscordPublicKey };
+/**
+ * Low-level Discord JSON API call. Defaults to POST against
+ * `https://discord.com/api/v10`. Bot-token auth is added only when a token is
+ * supplied (interaction webhook endpoints run unauthenticated). Does not throw
+ * on non-2xx, so callers must inspect `ok`/`status`.
+ */
+export declare function callDiscordApi(input: {
+    readonly apiBaseUrl?: string;
+    readonly body?: JsonObject;
+    readonly botToken?: DiscordBotToken;
+    readonly fetch?: DiscordFetch;
+    readonly method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+    readonly path: string;
+}): Promise<DiscordApiResponse>;
+/** Sends a bot-authenticated message to one Discord channel. */
+export declare function sendDiscordChannelMessage(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly channelId: string;
+}): Promise<DiscordPostedMessage>;
+/** Triggers Discord's short-lived channel typing indicator with bot auth. */
+export declare function triggerDiscordTypingIndicator(input: DiscordApiOptions & {
+    readonly channelId: string;
+}): Promise<void>;
+/** Edits the original response for a deferred Discord interaction. */
+export declare function editDiscordOriginalResponse(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly interactionToken: string;
+}): Promise<DiscordPostedMessage>;
+/** Creates a Discord interaction followup message. */
+export declare function createDiscordFollowupMessage(input: DiscordApiOptions & {
+    readonly body: DiscordMessageBody;
+    readonly interactionToken: string;
+}): Promise<DiscordPostedMessage>;
+/**
+ * JSON body for the Discord message endpoints Eve calls. When
+ * `allowed_mentions` is omitted, channel write helpers default it to
+ * {@link DISCORD_NO_MENTIONS} (no pings); set it explicitly to allow mentions.
+ */
+export interface DiscordMessageBody {
+    readonly allowed_mentions?: Readonly<Record<string, unknown>>;
+    readonly components?: readonly Readonly<Record<string, unknown>>[];
+    readonly content?: string;
+    readonly flags?: number;
+    readonly tts?: boolean;
+}
+/**
+ * Splits text into chunks Discord accepts as individual message contents. An
+ * empty string yields one empty chunk so callers can handle no-content messages.
+ */
+export declare function splitDiscordMessageContent(content: string): readonly string[];

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

@@ -0,0 +1,2 @@
+import{isObject}from"#shared/guards.js";import{parseJsonObject}from"#shared/json.js";import{resolveDiscordPublicKey}from"#public/channels/discord/verify.js";const DISCORD_NO_MENTIONS={parse:[]},DISCORD_MESSAGE_CONTENT_MAX_LENGTH=2e3;function discordContinuationToken(e,t){return`${e}:${t??``}`}async function resolveDiscordApplicationId(e){let t=e??process.env.DISCORD_APPLICATION_ID;if(!t)throw Error(`DISCORD_APPLICATION_ID is required.`);return typeof t==`function`?await t():t}async function resolveDiscordBotToken(e){let t=e??process.env.DISCORD_BOT_TOKEN;if(!t)throw Error(`DISCORD_BOT_TOKEN is required.`);return typeof t==`function`?await t():t}async function callDiscordApi(e){let n=e.fetch??fetch,r=new Headers;if(r.set(`content-type`,`application/json; charset=utf-8`),e.botToken!==void 0){let t=await resolveDiscordBotToken(e.botToken);r.set(`authorization`,`Bot ${t}`)}let i={headers:r,method:e.method??`POST`};e.body!==void 0&&(i.body=JSON.stringify(parseJsonObject(e.body)));let a=await n(`${e.apiBaseUrl??`https://discord.com/api/v10`}${e.path}`,i);return{body:await parseResponseBody(a),ok:a.ok,status:a.status}}async function sendDiscordChannelMessage(e){let t=await callDiscordApi({apiBaseUrl:e.apiBaseUrl,body:normalizeMessageBody(e.body),botToken:e.credentials?.botToken,fetch:e.fetch,path:`/channels/${encodeURIComponent(e.channelId)}/messages`});if(!t.ok)throw Error(`Discord create message failed with HTTP ${t.status}.`);return toPostedMessage(t.body)}async function triggerDiscordTypingIndicator(e){let t=await callDiscordApi({apiBaseUrl:e.apiBaseUrl,botToken:e.credentials?.botToken,fetch:e.fetch,path:`/channels/${encodeURIComponent(e.channelId)}/typing`});if(!t.ok)throw Error(`Discord typing indicator failed with HTTP ${t.status}.`)}async function editDiscordOriginalResponse(e){let t=await resolveDiscordApplicationId(e.credentials?.applicationId),n=await callDiscordApi({apiBaseUrl:e.apiBaseUrl,body:normalizeMessageBody(e.body),fetch:e.fetch,method:`PATCH`,path:`/webhooks/${encodeURIComponent(t)}/${encodeURIComponent(e.interactionToken)}/messages/@original`});if(!n.ok)throw Error(`Discord edit original response failed with HTTP ${n.status}.`);return toPostedMessage(n.body)}async function createDiscordFollowupMessage(e){let t=await resolveDiscordApplicationId(e.credentials?.applicationId),n=await callDiscordApi({apiBaseUrl:e.apiBaseUrl,body:normalizeMessageBody(e.body),fetch:e.fetch,path:`/webhooks/${encodeURIComponent(t)}/${encodeURIComponent(e.interactionToken)}`});if(!n.ok)throw Error(`Discord followup message failed with HTTP ${n.status}.`);return toPostedMessage(n.body)}function splitDiscordMessageContent(e){if(e.length<=2e3)return[e];let t=[],n=e;for(;n.length>DISCORD_MESSAGE_CONTENT_MAX_LENGTH;){let e=n.lastIndexOf(`
+`,DISCORD_MESSAGE_CONTENT_MAX_LENGTH);e<=0&&(e=n.lastIndexOf(` `,DISCORD_MESSAGE_CONTENT_MAX_LENGTH)),e<=0&&(e=DISCORD_MESSAGE_CONTENT_MAX_LENGTH),t.push(n.slice(0,e).trimEnd()),n=n.slice(e).trimStart()}return t.push(n),t}function normalizeMessageBody(e){let n={...e};return n.allowed_mentions===void 0&&(n.allowed_mentions=DISCORD_NO_MENTIONS),parseJsonObject(n)}function toPostedMessage(e){let t=parseMaybeObject(e);return{channelId:typeof t.channel_id==`string`?t.channel_id:void 0,id:typeof t.id==`string`?t.id:``,raw:e}}function parseMaybeObject(t){return isObject(t)?t:{}}async function parseResponseBody(e){let t=await e.text();if(!t)return null;try{return JSON.parse(t)}catch{return t}}export{DISCORD_MESSAGE_CONTENT_MAX_LENGTH,DISCORD_NO_MENTIONS,callDiscordApi,createDiscordFollowupMessage,discordContinuationToken,editDiscordOriginalResponse,resolveDiscordApplicationId,resolveDiscordBotToken,resolveDiscordPublicKey,sendDiscordChannelMessage,splitDiscordMessageContent,triggerDiscordTypingIndicator};

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

@@ -0,0 +1,15 @@
+import type { SessionAuthContext } from "#channel/types.js";
+import type { DiscordCommandInteraction } from "#public/channels/discord/inbound.js";
+import type { DiscordChannelEvents, DiscordCommandResult, DiscordContext } from "#public/channels/discord/discordChannel.js";
+/**
+ * Builds the default {@link SessionAuthContext} for a Discord command
+ * interaction: authenticator `discord-interaction`, guild-scoped
+ * issuer/principalId when invoked in a guild (else user-scoped), and
+ * `principalType` `service` for bot actors or `user` otherwise. Copies the
+ * channel, interaction, user, guild, and member-nick attributes.
+ */
+export declare function defaultDiscordAuth(interaction: DiscordCommandInteraction): SessionAuthContext;
+/** Default command hook: dispatch with Discord user auth. */
+export declare function defaultOnCommand(_ctx: DiscordContext, interaction: DiscordCommandInteraction): DiscordCommandResult;
+/** Built-in Discord event handlers for typing, replies, HITL, and terminal errors. */
+export declare const defaultEvents: DiscordChannelEvents;

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

@@ -0,0 +1,3 @@
+import{extractErrorId,formatErrorHint}from"#internal/logging.js";import{splitDiscordMessageContent}from"#public/channels/discord/api.js";import{renderInputRequestComponents}from"#public/channels/discord/hitl.js";function defaultDiscordAuth(e){let t={channel_id:e.channelId,interaction_id:e.id,user_id:e.user.id,username:e.user.username};return e.guildId!==void 0&&(t.guild_id=e.guildId),e.member?.nick!==void 0&&(t.member_nick=e.member.nick),{attributes:t,authenticator:`discord-interaction`,issuer:e.guildId?`discord:${e.guildId}`:`discord`,principalId:e.guildId?`discord:${e.guildId}:${e.user.id}`:`discord:${e.user.id}`,principalType:e.user.isBot?`service`:`user`}}function defaultOnCommand(e,t){return{auth:defaultDiscordAuth(t)}}const defaultEvents={async"turn.started"(e,t,n){await t.discord.startTyping()},async"actions.requested"(e,t,n){await t.discord.startTyping()},async"input.requested"(e,t,i){for(let i of e.requests){let e=splitDiscordMessageContent(i.prompt)[0]??i.prompt;await t.discord.post({components:renderInputRequestComponents(i),content:e})}},async"message.completed"(e,t,n){e.finishReason===`tool-calls`||!e.message||await t.discord.post(e.message)},async"session.failed"(n,r){let i=formatErrorHint(n),a=extractErrorId(n.details);await r.discord.post([`This session could not recover from an error${i}.`,``,`Start a new command to continue.`,...a?[``,`Error id: ${a}`]:[]].join(`
+`))},async"turn.failed"(n,r,i){let a=formatErrorHint(n),o=extractErrorId(n.details);await r.discord.post([`I hit an error while handling your request${a}.`,``,`Please try again, rephrase, or reach out if it keeps failing.`,...o?[``,`Error id: ${o}`]:[]].join(`
+`))}};export{defaultDiscordAuth,defaultEvents,defaultOnCommand};

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

@@ -0,0 +1,134 @@
+import type { DiscordInstrumentationMetadata } from "#public/channels/discord/index.js";
+import type { SessionAuthContext } from "#channel/types.js";
+import type { SessionContext } from "#public/definitions/callback-context.js";
+import type { ChannelSessionOps } from "#public/definitions/defineChannel.js";
+import type { HandleMessageStreamEvent } from "#protocol/message.js";
+import { type DiscordApiOptions, type DiscordApiResponse, type DiscordCredentials, type DiscordMessageBody, type DiscordPostedMessage } from "#public/channels/discord/api.js";
+import { type DiscordCommandInteraction } from "#public/channels/discord/inbound.js";
+import { type DiscordWebhookVerifier } from "#public/channels/discord/verify.js";
+import { type JsonObject } from "#shared/json.js";
+import { type Channel } from "#public/definitions/defineChannel.js";
+type EventData<T extends HandleMessageStreamEvent["type"]> = Extract<HandleMessageStreamEvent, {
+    type: T;
+}> extends {
+    data: infer D;
+} ? D : undefined;
+/** Pre-dispatch Discord context passed to inbound command hooks. */
+export interface DiscordContext {
+    readonly discord: DiscordHandle;
+}
+/** Channel-owned Discord context returned by `context()`. */
+export type DiscordChannelContext = DiscordContext & {
+    state: DiscordChannelState;
+};
+/** Event-handler Discord context, including session operations. */
+export interface DiscordEventContext extends DiscordChannelContext, ChannelSessionOps {
+}
+/** JSON-serializable Discord channel state. */
+export interface DiscordChannelState {
+    /** Discord channel id. */
+    channelId: string | null;
+    /** Discord message id once anchored, or an interaction placeholder before the first reply. */
+    conversationId: string | null;
+    /** Discord guild id, when the interaction was invoked in a guild. */
+    guildId: string | null;
+    /** Discord application id from the inbound interaction. */
+    applicationId: string | null;
+    /** Latest interaction token available to the channel. */
+    interactionToken: string | null;
+    /** Whether the channel has already edited the deferred original interaction response. */
+    initialResponseSent: boolean;
+    /** Whether `conversationId` is a real Discord message id. */
+    hasMessageAnchor: boolean;
+}
+/** Discord channel credentials. */
+export interface DiscordChannelCredentials extends DiscordCredentials {
+    /** Custom inbound webhook verifier. When supplied, Eve skips the `DISCORD_PUBLIC_KEY` fallback and delegates verification to it. */
+    readonly webhookVerifier?: DiscordWebhookVerifier;
+}
+/** Target accepted by `receive(discord, { target })` for proactive sessions. */
+export interface DiscordReceiveTarget {
+    readonly channelId: string;
+    readonly conversationId?: string;
+    readonly initialMessage?: string | DiscordMessageBody;
+}
+/**
+ * Result of an inbound Discord command hook. Return `null` to acknowledge the
+ * interaction without dispatching the agent.
+ * - `auth`: session auth context for the dispatched turn, or `null` for anonymous.
+ * - `ephemeral`: when `true`, the deferred reply is visible only to the invoking user.
+ * - `context`: model-visible context lines appended after the Discord context block.
+ */
+export type DiscordCommandResult = {
+    readonly auth: SessionAuthContext | null;
+    readonly ephemeral?: boolean;
+    readonly context?: readonly string[];
+} | null;
+/** Sync or async {@link DiscordCommandResult}. */
+export type DiscordCommandResultOrPromise = DiscordCommandResult | Promise<DiscordCommandResult>;
+type DiscordEventHandler<T extends HandleMessageStreamEvent["type"]> = (data: EventData<T>, channel: DiscordEventContext, ctx: SessionContext) => void | Promise<void>;
+type DiscordSessionFailedHandler = (data: EventData<"session.failed">, channel: DiscordEventContext) => void | Promise<void>;
+/** Per-event handlers for `discordChannel({ events })`. Supplied handlers override built-in defaults per key; unspecified events keep their defaults. `session.failed` receives only `(data, channel)`; every other handler also gets the session `ctx`. */
+export interface DiscordChannelEvents {
+    readonly "turn.started"?: DiscordEventHandler<"turn.started">;
+    readonly "actions.requested"?: DiscordEventHandler<"actions.requested">;
+    readonly "action.result"?: DiscordEventHandler<"action.result">;
+    readonly "message.completed"?: DiscordEventHandler<"message.completed">;
+    readonly "message.appended"?: DiscordEventHandler<"message.appended">;
+    readonly "input.requested"?: DiscordEventHandler<"input.requested">;
+    readonly "turn.failed"?: DiscordEventHandler<"turn.failed">;
+    readonly "turn.completed"?: DiscordEventHandler<"turn.completed">;
+    readonly "session.failed"?: DiscordSessionFailedHandler;
+    readonly "session.completed"?: DiscordEventHandler<"session.completed">;
+    readonly "session.waiting"?: DiscordEventHandler<"session.waiting">;
+    readonly "authorization.required"?: DiscordEventHandler<"authorization.required">;
+    readonly "authorization.completed"?: DiscordEventHandler<"authorization.completed">;
+}
+/** Configuration for {@link discordChannel}. */
+export interface DiscordChannelConfig {
+    readonly api?: Omit<DiscordApiOptions, "credentials">;
+    readonly credentials?: DiscordChannelCredentials;
+    /** Override the default interaction route path (`/eve/v1/discord`). */
+    readonly route?: string;
+    /** Inbound command hook. Defaults to user-scoped Discord auth and dispatch. Return `{ auth }` to dispatch, or `null` to acknowledge without running the agent. */
+    onCommand?(ctx: DiscordContext, interaction: DiscordCommandInteraction): DiscordCommandResultOrPromise;
+    readonly events?: DiscordChannelEvents;
+}
+/** Low-level Discord handle exposed to hooks and event handlers. */
+export interface DiscordHandle {
+    /** Discord application id when known. */
+    readonly applicationId: string | undefined;
+    /** Discord channel id. */
+    readonly channelId: string;
+    /** Current Eve conversation id, usually the Discord anchor message id. */
+    readonly conversationId: string;
+    /** Discord guild id when known. */
+    readonly guildId: string | undefined;
+    /** Latest Discord interaction token when known. */
+    readonly interactionToken: string | undefined;
+    /** Raw Discord API escape hatch. */
+    request(path: string, body: JsonObject, options?: DiscordRequestOptions): Promise<DiscordApiResponse>;
+    /** Posts to the current conversation: interaction response or followup when an interaction token and application id exist, else a channel message. Splits over-length content, returning the first. */
+    post(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Sends a bot-authenticated message to this Discord channel. */
+    sendChannelMessage(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Edits the deferred original interaction response. */
+    editOriginalResponse(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Creates an interaction followup message. */
+    followup(message: string | DiscordMessageBody): Promise<DiscordPostedMessage>;
+    /** Triggers Discord's short-lived typing indicator. Ignores any failure. */
+    startTyping(): Promise<void>;
+}
+/** Options for {@link DiscordHandle.request}. */
+export interface DiscordRequestOptions {
+    /** When `true`, attaches bot-token authorization; otherwise the raw request runs unauthenticated, suiting interaction webhook endpoints. */
+    readonly botAuth?: boolean;
+    /** HTTP method for the raw request. Defaults to `POST`. */
+    readonly method?: "DELETE" | "GET" | "PATCH" | "POST" | "PUT";
+}
+/** Concrete return type of {@link discordChannel}. */
+export interface DiscordChannel extends Channel<DiscordChannelState, DiscordReceiveTarget, DiscordInstrumentationMetadata> {
+}
+/** Discord channel factory for HTTP Interactions and proactive channel messages. */
+export declare function discordChannel(config?: DiscordChannelConfig): DiscordChannel;
+export {};

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

@@ -0,0 +1 @@
+import{createLogger,logError}from"#internal/logging.js";import{parseJsonObject}from"#shared/json.js";import"#public/channels/discord/verify.js";import{callDiscordApi,createDiscordFollowupMessage,discordContinuationToken,editDiscordOriginalResponse,sendDiscordChannelMessage,splitDiscordMessageContent,triggerDiscordTypingIndicator}from"#public/channels/discord/api.js";import{buildFreeformModalResponse,deriveComponentInputResponses,deriveModalInputResponses,isDiscordFreeformComponent}from"#public/channels/discord/hitl.js";import{defaultEvents,defaultOnCommand}from"#public/channels/discord/defaults.js";import{DISCORD_INTERACTION_RESPONSE_TYPE,DISCORD_INTERACTION_TYPE,commandInteractionMessage,formatDiscordContextBlock,parseDiscordInteraction}from"#public/channels/discord/inbound.js";import{discordDeferredJson,discordJson,discordJsonBody,readMessageContent}from"#public/channels/discord/responses.js";import{verifyDiscordInbound}from"#public/channels/discord/verifyInbound.js";import{POST,defineChannel}from"#public/definitions/defineChannel.js";const log=createLogger(`discord.channel`);function discordChannel(e={}){let t=e.onCommand??defaultOnCommand,r={...defaultEvents,...e.events};return defineChannel({kindHint:`discord`,state:initialDiscordState(),metadata:e=>({channelId:e.channelId,guildId:e.guildId}),context(t,n){return rebuildDiscordContext(t,n,e)},routes:[POST(e.route??`/eve/v1/discord`,async(r,{send:i,waitUntil:a})=>{let o=await verifyDiscordInbound(r,e.credentials);if(o===null)return new Response(`unauthorized`,{status:401});let s;try{s=parseJsonObject(JSON.parse(o))}catch(e){return log.warn(`inbound Discord body is not valid JSON`,{error:e}),discordJson({content:`invalid request`,ephemeral:!0})}if(s.type===DISCORD_INTERACTION_TYPE.PING)return discordJson({type:DISCORD_INTERACTION_RESPONSE_TYPE.PONG});let c=parseDiscordInteraction(s);return c===null?discordJson({content:`Unsupported Discord interaction.`,ephemeral:!0}):handleInteraction({config:e,interaction:c,onCommand:t,send:i,waitUntil:a})})],async receive(t,{send:n}){let r=t.target,i=readString(r.channelId);if(!i)throw Error(`discordChannel().receive requires target.channelId.`);let o=readString(r.conversationId),s=r.initialMessage;if(s!==void 0&&o!==void 0)throw Error("discordChannel().receive: `conversationId` and `initialMessage` are mutually exclusive.");let c=o??``,l=o!==void 0;if(s!==void 0){let t=await buildDiscordHandle({config:e,state:{...initialDiscordState(),channelId:i}}).sendChannelMessage(s);c=t.id,l=t.id.length>0}return n(t.message,{auth:t.auth,continuationToken:discordContinuationToken(i,c),state:{applicationId:null,channelId:i,conversationId:c||null,guildId:null,hasMessageAnchor:l,initialResponseSent:!0,interactionToken:null}})},events:r})}function rebuildDiscordContext(e,t,n){return{discord:buildDiscordHandle({config:n,session:t,state:e}),state:e}}function buildDiscordHandle(e){let n=e.config.api,c=e.state,u=mergeCredentials(e.config.credentials,c);function anchor(t){!t.id||c.hasMessageAnchor||(c.conversationId=t.id,c.hasMessageAnchor=!0,c.channelId&&e.session?.setContinuationToken(discordContinuationToken(c.channelId,t.id)))}async function sendViaChannel(e){let t=c.channelId??``;if(!t)throw Error(`discordChannel: missing channel id for outbound message.`);let r=await sendDiscordChannelMessage({apiBaseUrl:n?.apiBaseUrl,body:normalizePostInput(e),credentials:u,fetch:n?.fetch,channelId:t});return anchor(r),r}async function editOriginal(e){let t=c.interactionToken??``;if(!t)throw Error(`discordChannel: missing interaction token for original response edit.`);let r=await editDiscordOriginalResponse({apiBaseUrl:n?.apiBaseUrl,body:normalizePostInput(e),credentials:u,fetch:n?.fetch,interactionToken:t});return c.initialResponseSent=!0,anchor(r),r}async function followup(e){let t=c.interactionToken??``;if(!t)throw Error(`discordChannel: missing interaction token for followup message.`);let r=await createDiscordFollowupMessage({apiBaseUrl:n?.apiBaseUrl,body:normalizePostInput(e),credentials:u,fetch:n?.fetch,interactionToken:t});return anchor(r),r}async function startTyping(){let e=c.channelId??``;if(e)try{await triggerDiscordTypingIndicator({apiBaseUrl:n?.apiBaseUrl,credentials:u,fetch:n?.fetch,channelId:e})}catch(n){logError(log,`Discord typing indicator failed — swallowed`,n,{channelId:e})}}return{applicationId:c.applicationId??void 0,channelId:c.channelId??``,conversationId:c.conversationId??``,guildId:c.guildId??void 0,interactionToken:c.interactionToken??void 0,request(e,t,i){return callDiscordApi({apiBaseUrl:n?.apiBaseUrl,body:t,botToken:i?.botAuth===!0?u.botToken:void 0,fetch:n?.fetch,method:i?.method,path:e})},async post(e){let t=expandPostBodies(normalizePostInput(e)),n;for(let e of t){let t=await postOne({body:e,editOriginal,followup,sendViaChannel,state:c});n===void 0&&(n=t)}return n??{id:``,raw:null}},editOriginalResponse:editOriginal,followup,sendChannelMessage:sendViaChannel,startTyping}}async function postOne(e){if(e.state.interactionToken&&e.state.applicationId)try{return e.state.initialResponseSent?await e.followup(e.body):await e.editOriginal(e.body)}catch(e){log.warn(`Discord interaction-token delivery failed, falling back to channel message`,{error:e})}return e.sendViaChannel(e.body)}async function handleInteraction(e){return e.interaction.type===DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND?handleCommandInteraction({config:e.config,interaction:e.interaction,onCommand:e.onCommand,send:e.send,waitUntil:e.waitUntil}):e.interaction.type===DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT?handleComponentInteraction({interaction:e.interaction,send:e.send,waitUntil:e.waitUntil}):handleModalSubmitInteraction({interaction:e.interaction,send:e.send,waitUntil:e.waitUntil})}async function handleCommandInteraction(e){let t=stateFromInteraction(e.interaction,{conversationId:e.interaction.id,hasMessageAnchor:!1,initialResponseSent:!1}),n={discord:buildDiscordHandle({config:e.config,state:t})},r;try{r=await e.onCommand(n,e.interaction)}catch(e){return log.error(`command handler failed`,{error:e}),discordJson({content:`The Discord command handler failed.`,ephemeral:!0})}return r==null?discordJson({content:`Command ignored.`,ephemeral:!0}):(e.waitUntil(dispatchCommand({interaction:e.interaction,result:r,send:e.send,state:t})),discordDeferredJson(r.ephemeral===!0))}function handleComponentInteraction(e){if(isDiscordFreeformComponent(e.interaction.customId)){let t=readMessageContent(e.interaction.raw);return discordJsonBody(buildFreeformModalResponse({customId:e.interaction.customId,prompt:t}))}let t=deriveComponentInputResponses(e.interaction);return t.length>0&&e.waitUntil(dispatchInputResponses({conversationId:e.interaction.messageId,inputResponses:t,interaction:e.interaction,send:e.send})),discordJsonBody({type:DISCORD_INTERACTION_RESPONSE_TYPE.DEFERRED_UPDATE_MESSAGE})}function handleModalSubmitInteraction(e){let t=deriveModalInputResponses(e.interaction);return t.length>0&&e.waitUntil(dispatchInputResponses({conversationId:e.interaction.messageId??e.interaction.id,inputResponses:t,interaction:e.interaction,send:e.send})),discordJson({content:`Answer received.`,ephemeral:!0})}async function dispatchCommand(e){let t=commandInteractionMessage(e.interaction),n=formatDiscordContextBlock({channelId:e.interaction.channelId,commandName:e.interaction.commandName,guildId:e.interaction.guildId,interactionId:e.interaction.id,userId:e.interaction.user.id,username:e.interaction.user.username}),r=e.result.context??[];try{await e.send({message:t,context:[n,...r]},{auth:e.result.auth,continuationToken:discordContinuationToken(e.interaction.channelId,e.interaction.id),state:e.state})}catch(e){log.error(`command delivery failed`,{error:e})}}async function dispatchInputResponses(e){try{await e.send({inputResponses:e.inputResponses},{auth:null,continuationToken:discordContinuationToken(e.interaction.channelId,e.conversationId),state:stateFromInteraction(e.interaction,{conversationId:e.conversationId,hasMessageAnchor:!0,initialResponseSent:!0})})}catch(e){log.error(`interaction response delivery failed`,{error:e})}}function stateFromInteraction(e,t){return{applicationId:e.applicationId,channelId:e.channelId,conversationId:t.conversationId,guildId:e.guildId??null,hasMessageAnchor:t.hasMessageAnchor,initialResponseSent:t.initialResponseSent,interactionToken:e.token}}function initialDiscordState(){return{applicationId:null,channelId:null,conversationId:null,guildId:null,hasMessageAnchor:!1,initialResponseSent:!1,interactionToken:null}}function mergeCredentials(e,t){return{applicationId:t.applicationId??e?.applicationId,botToken:e?.botToken,publicKey:e?.publicKey,webhookVerifier:e?.webhookVerifier}}function normalizePostInput(e){return typeof e==`string`?{content:e}:e}function expandPostBodies(e){return typeof e.content==`string`?splitDiscordMessageContent(e.content).map((t,n)=>n===0?{...e,content:t}:{allowed_mentions:e.allowed_mentions,content:t}):[e]}function readString(e){return typeof e==`string`&&e.length>0?e:void 0}export{discordChannel};

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

@@ -0,0 +1,47 @@
+/**
+ * Discord HITL component rendering + decode helpers.
+ *
+ * Discord components carry a `custom_id` with a 100-character cap. Eve
+ * encodes only the request id and, for buttons, the selected option id.
+ */
+import { type DiscordComponentInteraction, type DiscordModalSubmitInteraction } from "#public/channels/discord/inbound.js";
+import type { InputRequest, InputResponse } from "#runtime/input/types.js";
+/** Maps Discord component kinds (ACTION_ROW, BUTTON, STRING_SELECT, TEXT_INPUT) to their wire `type` integers used in component payloads. */
+export declare const DISCORD_COMPONENT_TYPE: {
+    readonly ACTION_ROW: 1;
+    readonly BUTTON: 2;
+    readonly STRING_SELECT: 3;
+    readonly TEXT_INPUT: 4;
+};
+/** Custom id prefix for selectable HITL controls. */
+export declare const DISCORD_HITL_CUSTOM_ID_PREFIX = "eve_input:";
+/** Custom id prefix for the button/modal freeform flow. */
+export declare const DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX = "eve_input_freeform:";
+/** Text-input id inside the freeform modal. */
+export declare const DISCORD_HITL_FREEFORM_TEXT_INPUT_ID = "eve_freeform_text";
+/**
+ * Renders an input request into Discord action-row components: a string-select
+ * for `display: "select"` with options, else option buttons chunked into rows,
+ * else a freeform-answer button when freeform is accepted. Empty array when no
+ * control applies.
+ */
+export declare function renderInputRequestComponents(request: InputRequest): readonly Readonly<Record<string, unknown>>[];
+/** Builds a Discord modal response for one freeform HITL request. */
+export declare function buildFreeformModalResponse(input: {
+    readonly customId: string;
+    readonly prompt: string | undefined;
+}): Record<string, unknown>;
+/** Returns true when a component custom id starts the freeform modal flow. */
+export declare function isDiscordFreeformComponent(customId: string): boolean;
+/**
+ * Decodes an Eve HITL component interaction into input responses. Empty array
+ * if the custom id is not an Eve HITL id; otherwise one response from the
+ * encoded option id (buttons) or the first selected value (selects).
+ */
+export declare function deriveComponentInputResponses(interaction: DiscordComponentInteraction): readonly InputResponse[];
+/**
+ * Decodes an Eve freeform modal submission into a single text input response.
+ * Empty array unless the custom id matches the freeform prefix and the freeform
+ * text field is present.
+ */
+export declare function deriveModalInputResponses(interaction: DiscordModalSubmitInteraction): readonly InputResponse[];

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

@@ -0,0 +1 @@
+import{DISCORD_INTERACTION_RESPONSE_TYPE}from"#public/channels/discord/inbound.js";const DISCORD_COMPONENT_TYPE={ACTION_ROW:1,BUTTON:2,STRING_SELECT:3,TEXT_INPUT:4},DISCORD_HITL_CUSTOM_ID_PREFIX=`eve_input:`,DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX=`eve_input_freeform:`,DISCORD_HITL_FREEFORM_TEXT_INPUT_ID=`eve_freeform_text`;function renderInputRequestComponents(e){let i=e.options,a=e.allowFreeform===!0||!i||i.length===0;return i&&i.length>0&&e.display===`select`?[{components:[{custom_id:encodeHitlCustomId(DISCORD_HITL_CUSTOM_ID_PREFIX,{requestId:e.requestId}),options:i.slice(0,25).map(e=>{let t={label:truncate(e.label,100),value:truncate(e.id,100)};return e.description!==void 0&&(t.description=truncate(e.description,100)),t}),placeholder:`Choose an option`,type:DISCORD_COMPONENT_TYPE.STRING_SELECT}],type:DISCORD_COMPONENT_TYPE.ACTION_ROW}]:i&&i.length>0?chunk(i.slice(0,25),5).map(r=>({components:r.map(r=>({custom_id:encodeHitlCustomId(DISCORD_HITL_CUSTOM_ID_PREFIX,{optionId:r.id,requestId:e.requestId}),label:truncate(r.label,80),style:toDiscordButtonStyle(r.style),type:DISCORD_COMPONENT_TYPE.BUTTON})),type:DISCORD_COMPONENT_TYPE.ACTION_ROW})):a?[{components:[{custom_id:encodeHitlCustomId(DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX,{requestId:e.requestId}),label:`Type your answer`,style:1,type:DISCORD_COMPONENT_TYPE.BUTTON}],type:DISCORD_COMPONENT_TYPE.ACTION_ROW}]:[]}function buildFreeformModalResponse(n){let a=decodeHitlCustomId(n.customId,DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX);if(!a)throw Error(`discordChannel: freeform custom_id is malformed.`);return{data:{components:[{components:[{custom_id:DISCORD_HITL_FREEFORM_TEXT_INPUT_ID,label:`Answer`,max_length:4e3,min_length:1,placeholder:`Type your answer here...`,required:!0,style:2,type:DISCORD_COMPONENT_TYPE.TEXT_INPUT}],type:DISCORD_COMPONENT_TYPE.ACTION_ROW}],custom_id:encodeHitlCustomId(DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX,{requestId:a.requestId}),title:truncate(n.prompt??`Your answer`,45)},type:DISCORD_INTERACTION_RESPONSE_TYPE.MODAL}}function isDiscordFreeformComponent(e){return decodeHitlCustomId(e,DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX)!==null}function deriveComponentInputResponses(e){let t=decodeHitlCustomId(e.customId,DISCORD_HITL_CUSTOM_ID_PREFIX);if(!t)return[];if(t.optionId!==void 0)return[{optionId:t.optionId,requestId:t.requestId}];let r=e.values[0];return r===void 0?[]:[{optionId:r,requestId:t.requestId}]}function deriveModalInputResponses(e){let t=decodeHitlCustomId(e.customId,DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX),n=e.textInputs[DISCORD_HITL_FREEFORM_TEXT_INPUT_ID];return!t||n===void 0?[]:[{requestId:t.requestId,text:n}]}function encodeHitlCustomId(e,t){let n=`${e}${Buffer.from(JSON.stringify(t),`utf8`).toString(`base64url`)}`;if(n.length>100)throw Error(`discordChannel: HITL custom_id exceeded Discord's 100-character limit.`);return n}function decodeHitlCustomId(e,t){if(!e.startsWith(t))return null;try{let n=Buffer.from(e.slice(t.length),`base64url`).toString(`utf8`),r=JSON.parse(n);if(typeof r.requestId!=`string`||r.requestId.length===0)return null;let i={requestId:r.requestId};return typeof r.optionId==`string`?{...i,optionId:r.optionId}:i}catch{return null}}function toDiscordButtonStyle(e){return e===`primary`?1:e===`danger`?4:2}function truncate(e,t){if(e.length<=t)return e;let n=Math.max(0,t-3);return`${e.slice(0,n).trimEnd()}...`}function chunk(e,t){let n=[];for(let r=0;r<e.length;r+=t)n.push(e.slice(r,r+t));return n}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};

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

@@ -0,0 +1,106 @@
+/**
+ * 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.
+ */
+/** Maps the Discord interaction kinds the channel handles to their wire `type` integers. */
+export declare const DISCORD_INTERACTION_TYPE: {
+    readonly APPLICATION_COMMAND: 2;
+    readonly MESSAGE_COMPONENT: 3;
+    readonly MODAL_SUBMIT: 5;
+    readonly PING: 1;
+};
+/** Maps Discord interaction callback kinds to the wire `type` integers used in interaction responses. */
+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 `flags` bit (1 << 6 = 64) marking a response ephemeral (visible only to the invoking user). */
+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. `value` holds the
+ * primitive argument for leaf options and is undefined for subcommands and
+ * subcommand groups, which carry their child options in `options`.
+ */
+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. `componentType` is Discord's
+ * raw component-type integer (0 when absent). `values` holds the selected option
+ * ids for string-select components and is empty for buttons.
+ */
+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;
+/**
+ * Fields rendered into the model-visible `<discord_context>` block by
+ * {@link formatDiscordContextBlock}. The optional fields (username, guildId,
+ * commandName) are omitted from the block when not provided.
+ */
+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;
+/** Returns the model-facing prompt for a command: the value of a `message` option when present and non-blank, otherwise a reconstructed `/command opt:value ...` string. */
+export declare function commandInteractionMessage(interaction: DiscordCommandInteraction): string;
+/** Renders one {@link DiscordInboundContext} as a deterministic context block. */
+export declare function formatDiscordContextBlock(context: DiscordInboundContext): string;

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

@@ -0,0 +1,2 @@
+import{isNonEmptyString,isObject}from"#shared/guards.js";const DISCORD_INTERACTION_TYPE={APPLICATION_COMMAND:2,MESSAGE_COMPONENT:3,MODAL_SUBMIT:5,PING:1},DISCORD_INTERACTION_RESPONSE_TYPE={CHANNEL_MESSAGE_WITH_SOURCE:4,DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE:5,DEFERRED_UPDATE_MESSAGE:6,MODAL:9,PONG:1},DISCORD_EPHEMERAL_MESSAGE_FLAG=64;function parseDiscordInteraction(e){if(!isObject(e))return null;let r=e.type;return r===DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND?parseCommandInteraction(e):r===DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT?parseComponentInteraction(e):r===DISCORD_INTERACTION_TYPE.MODAL_SUBMIT?parseModalSubmitInteraction(e):null}function commandInteractionMessage(e){let t=findOptionValue(e.options,`message`);if(typeof t==`string`&&t.trim().length>0)return t;let n=formatCommandOptions(e.options);return n?`/${e.commandName} ${n}`:`/${e.commandName}`}function formatDiscordContextBlock(e){return[`<discord_context>`,`response_medium: discord`,`response_instructions: Reply for Discord in concise Markdown. Avoid mass mentions, long tables, and messages that need more than a few short posts.`,`user_id: ${e.userId}`,...e.username?[`username: ${e.username}`]:[],`channel_id: ${e.channelId}`,...e.guildId?[`guild_id: ${e.guildId}`]:[],`interaction_id: ${e.interactionId}`,...e.commandName?[`command_name: ${e.commandName}`]:[],`</discord_context>`].join(`
+`)}function parseCommandInteraction(r){let i=parseInteractionBase(r),a=isObject(r.data)?r.data:null;return!i||!a||!isNonEmptyString(a.name)?null:{...i,commandId:isNonEmptyString(a.id)?a.id:void 0,commandName:a.name,options:parseOptions(a.options),type:DISCORD_INTERACTION_TYPE.APPLICATION_COMMAND}}function parseComponentInteraction(r){let i=parseInteractionBase(r),a=isObject(r.data)?r.data:null,o=isObject(r.message)?r.message:null;if(!i||!a||!isNonEmptyString(a.custom_id))return null;let s=isNonEmptyString(o?.id)?o.id:``;return s?{...i,componentType:typeof a.component_type==`number`?a.component_type:0,customId:a.custom_id,messageId:s,type:DISCORD_INTERACTION_TYPE.MESSAGE_COMPONENT,values:Array.isArray(a.values)?a.values.filter(e=>typeof e==`string`):[]}:null}function parseModalSubmitInteraction(r){let i=parseInteractionBase(r),a=isObject(r.data)?r.data:null;if(!i||!a||!isNonEmptyString(a.custom_id))return null;let o=isObject(r.message)?r.message:null;return{...i,customId:a.custom_id,messageId:isNonEmptyString(o?.id)?o.id:void 0,textInputs:parseTextInputs(a.components),type:DISCORD_INTERACTION_TYPE.MODAL_SUBMIT}}function parseInteractionBase(t){if(!isNonEmptyString(t.id)||!isNonEmptyString(t.application_id)||!isNonEmptyString(t.channel_id)||!isNonEmptyString(t.token))return null;let n=parseInteractionUser(t);return n?{applicationId:t.application_id,channelId:t.channel_id,guildId:isNonEmptyString(t.guild_id)?t.guild_id:void 0,id:t.id,member:parseMember(t.member),raw:t,token:t.token,user:n}:null}function parseInteractionUser(e){return parseUser(e.user)||(parseMember(e.member)?.user??null)}function parseMember(n){if(!isObject(n))return;let r=parseUser(n.user);if(r)return{nick:isNonEmptyString(n.nick)?n.nick:void 0,roles:Array.isArray(n.roles)?n.roles.filter(e=>typeof e==`string`):[],user:r}}function parseUser(n){return!isObject(n)||!isNonEmptyString(n.id)||!isNonEmptyString(n.username)?null:{avatar:isNonEmptyString(n.avatar)?n.avatar:void 0,discriminator:isNonEmptyString(n.discriminator)?n.discriminator:void 0,globalName:isNonEmptyString(n.global_name)?n.global_name:void 0,id:n.id,isBot:n.bot===!0,username:n.username}}function parseOptions(n){if(!Array.isArray(n))return[];let r=[];for(let i of n){if(!isObject(i)||!isNonEmptyString(i.name))continue;let n={name:i.name,options:parseOptions(i.options),value:parseOptionValue(i.value)};r.push(n)}return r}function parseOptionValue(e){if(typeof e==`string`||typeof e==`number`||typeof e==`boolean`)return e}function parseTextInputs(n){let r={};if(!Array.isArray(n))return r;for(let i of n)if(!(!isObject(i)||!Array.isArray(i.components)))for(let n of i.components)isObject(n)&&isNonEmptyString(n.custom_id)&&typeof n.value==`string`&&(r[n.custom_id]=n.value);return r}function findOptionValue(e,t){for(let n of e){if(n.name===t&&n.value!==void 0)return n.value;let e=findOptionValue(n.options,t);if(e!==void 0)return e}}function formatCommandOptions(e){return e.map(formatOption).filter(e=>e.length>0).join(` `)}function formatOption(e){if(e.value!==void 0)return`${e.name}:${String(e.value)}`;let t=formatCommandOptions(e.options);return t?`${e.name} ${t}`:e.name}export{DISCORD_EPHEMERAL_MESSAGE_FLAG,DISCORD_INTERACTION_RESPONSE_TYPE,DISCORD_INTERACTION_TYPE,commandInteractionMessage,formatDiscordContextBlock,parseDiscordInteraction};

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

@@ -0,0 +1,23 @@
+/**
+ * AI SDK conversation-message shape that the harness uses as the unit of
+ * session history and turn input. Re-exported from the `ai` package so
+ * authors wiring up the Discord channel can type their own message arrays
+ * without taking a direct `ai` dependency.
+ */
+export type { ModelMessage } from "ai";
+/**
+ * Instrumentation metadata the channel's `metadata` callback reports for
+ * Discord sessions, used for tracing and observability.
+ */
+export interface DiscordInstrumentationMetadata extends Record<string, unknown> {
+    /** Originating Discord channel id, or `null` when unavailable. */
+    readonly channelId: string | null;
+    /** Originating Discord guild id, or `null` when the interaction was not in a guild. */
+    readonly guildId: string | null;
+}
+export { discordChannel, type DiscordChannel, type DiscordChannelConfig, type DiscordChannelCredentials, type DiscordChannelEvents, type DiscordChannelState, type DiscordCommandResult, type DiscordCommandResultOrPromise, type DiscordContext, type DiscordEventContext, type DiscordHandle, type DiscordReceiveTarget, 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, 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 @@
+import{verifyDiscordRequest,verifyDiscordSignature}from"#public/channels/discord/verify.js";import{DISCORD_MESSAGE_CONTENT_MAX_LENGTH,DISCORD_NO_MENTIONS,callDiscordApi,createDiscordFollowupMessage,discordContinuationToken,editDiscordOriginalResponse,resolveDiscordApplicationId,resolveDiscordBotToken,resolveDiscordPublicKey,sendDiscordChannelMessage,splitDiscordMessageContent,triggerDiscordTypingIndicator}from"#public/channels/discord/api.js";import{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";import{defaultDiscordAuth}from"#public/channels/discord/defaults.js";import{DISCORD_EPHEMERAL_MESSAGE_FLAG,DISCORD_INTERACTION_RESPONSE_TYPE,DISCORD_INTERACTION_TYPE,commandInteractionMessage,formatDiscordContextBlock,parseDiscordInteraction}from"#public/channels/discord/inbound.js";import{discordChannel}from"#public/channels/discord/discordChannel.js";export{DISCORD_COMPONENT_TYPE,DISCORD_EPHEMERAL_MESSAGE_FLAG,DISCORD_HITL_CUSTOM_ID_PREFIX,DISCORD_HITL_FREEFORM_CUSTOM_ID_PREFIX,DISCORD_HITL_FREEFORM_TEXT_INPUT_ID,DISCORD_INTERACTION_RESPONSE_TYPE,DISCORD_INTERACTION_TYPE,DISCORD_MESSAGE_CONTENT_MAX_LENGTH,DISCORD_NO_MENTIONS,buildFreeformModalResponse,callDiscordApi,commandInteractionMessage,createDiscordFollowupMessage,defaultDiscordAuth,deriveComponentInputResponses,deriveModalInputResponses,discordChannel,discordContinuationToken,editDiscordOriginalResponse,formatDiscordContextBlock,isDiscordFreeformComponent,parseDiscordInteraction,renderInputRequestComponents,resolveDiscordApplicationId,resolveDiscordBotToken,resolveDiscordPublicKey,sendDiscordChannelMessage,splitDiscordMessageContent,triggerDiscordTypingIndicator,verifyDiscordRequest,verifyDiscordSignature};

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 @@
+import{isNonEmptyString,isObject}from"#shared/guards.js";import{parseJsonObject}from"#shared/json.js";import{DISCORD_EPHEMERAL_MESSAGE_FLAG,DISCORD_INTERACTION_RESPONSE_TYPE}from"#public/channels/discord/inbound.js";function discordDeferredJson(e){let t={type:DISCORD_INTERACTION_RESPONSE_TYPE.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE};return e&&(t.data={flags:DISCORD_EPHEMERAL_MESSAGE_FLAG}),discordJsonBody(t)}function discordJson(e){if(`content`in e&&typeof e.content==`string`){let t={allowed_mentions:{parse:[]},content:e.content};return e.ephemeral===!0&&(t.flags=DISCORD_EPHEMERAL_MESSAGE_FLAG),discordJsonBody({data:t,type:DISCORD_INTERACTION_RESPONSE_TYPE.CHANNEL_MESSAGE_WITH_SOURCE})}return discordJsonBody(e)}function discordJsonBody(e){return Response.json(parseJsonObject(e),{headers:{"content-type":`application/json; charset=utf-8`}})}function readMessageContent(n){let r=isObject(n.message)?n.message:null;return isNonEmptyString(r?.content)?r.content:void 0}export{discordDeferredJson,discordJson,discordJsonBody,readMessageContent};

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

@@ -0,0 +1,46 @@
+/**
+ * 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. Replaces Ed25519 verification
+ * when an integration authenticates forwarded webhooks before they reach
+ * Eve. Receives the request and raw body.
+ *
+ * Return a falsy value to reject the request. Return a string to accept it
+ * and use that string as the (possibly rewritten) body. Return any other
+ * truthy value to accept it and keep the original body.
+ */
+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 interaction signature over `timestamp + body`.
+ * `publicKey` and `signature` are hex-encoded. Returns false (never throws) on
+ * malformed input or a length/signature mismatch.
+ */
+export declare function verifyDiscordSignature(input: {
+    readonly body: string;
+    readonly publicKey: string;
+    readonly signature: string;
+    readonly timestamp: string;
+}): boolean;

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

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{createPublicKey,verify}from"node:crypto";const log=createLogger(`discord.verify`),ED25519_SPKI_PREFIX=Buffer.from(`302a300506032b6570032100`,`hex`);async function resolveDiscordPublicKey(e){let t=e??process.env.DISCORD_PUBLIC_KEY;if(!t)throw Error(`DISCORD_PUBLIC_KEY is required.`);return typeof t==`function`?await t():t}async function verifyDiscordRequest(e,t){let n=await e.text();if(t.webhookVerifier!==void 0){let r=await t.webhookVerifier(e,n);if(!r)throw Error(`discordChannel: inbound webhook verifier rejected the request.`);return typeof r==`string`?r:n}let r=await resolveDiscordPublicKey(t.publicKey),i=e.headers.get(`x-signature-ed25519`)??``,a=e.headers.get(`x-signature-timestamp`)??``;if(!i||!a)throw Error(`discordChannel: inbound request missing Discord signature headers.`);let o=Number(a);if(!Number.isFinite(o))throw Error(`discordChannel: inbound request has malformed timestamp.`);let s=t.maxSkewSeconds??300,c=Math.floor(Date.now()/1e3);if(Math.abs(c-o)>s)throw Error(`discordChannel: inbound request timestamp outside allowed skew.`);if(!verifyDiscordSignature({body:n,publicKey:r,signature:i,timestamp:a}))throw Error(`discordChannel: inbound request signature mismatch.`);return n}function verifyDiscordSignature(e){try{let r=Buffer.from(e.publicKey,`hex`),a=Buffer.from(e.signature,`hex`);if(r.length!==32||a.length!==64)return!1;let o=createPublicKey({format:`der`,key:Buffer.concat([ED25519_SPKI_PREFIX,r]),type:`spki`});return verify(null,Buffer.from(`${e.timestamp}${e.body}`),o,a)}catch(e){return log.debug(`Discord signature verification threw`,{error:e}),!1}}export{resolveDiscordPublicKey,verifyDiscordRequest,verifyDiscordSignature};

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

@@ -0,0 +1,6 @@
+import type { DiscordChannelCredentials } from "#public/channels/discord/discordChannel.js";
+/**
+ * Verifies an inbound Discord request and returns its raw body, or
+ * `null` when verification fails.
+ */
+export declare function verifyDiscordInbound(req: Request, credentials: DiscordChannelCredentials | undefined): Promise<string | null>;

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

@@ -0,0 +1 @@
+import{createLogger}from"#internal/logging.js";import{verifyDiscordRequest}from"#public/channels/discord/verify.js";const log=createLogger(`discord.channel`);async function verifyDiscordInbound(e,t){try{return await verifyDiscordRequest(e,{publicKey:t?.webhookVerifier?void 0:t?.publicKey,webhookVerifier:t?.webhookVerifier})}catch(e){return log.warn(`discord inbound verification failed`,{error:e}),null}}export{verifyDiscordInbound};