@zhin.js/adapter-discord 1.1.18 → 1.1.20

package/lib/gateway.d.ts

@@ -1,133 +1,15 @@
-import { GatewayIntentBits, type RESTOptions, type MessageCreateOptions } from 'discord.js';
+import type { EndpointEventSink } from 'zhin.js/adapter';
+import { Client, GatewayIntentBits, type RESTOptions, type ClientOptions, type MessageCreateOptions } from 'discord.js';
 import { type DiscordButtonInbound, type DiscordInboundMessage, type DiscordOutboundBody, type ResolvedDiscordGatewayConfig } from './protocol.js';
 export declare const DEFAULT_INTENTS: GatewayIntentBits[];
-/** Minimal client surface used by the endpoint (real discord.js or test mock). */
-export interface DiscordClientTransport {
-    isReady?(): boolean;
-    login(token: string): Promise<string>;
-    destroy(): Promise<void>;
-    on(event: string, listener: (...args: unknown[]) => void): void;
-    once(event: string, listener: (...args: unknown[]) => void): void;
-    removeAllListeners(): void;
-    readonly user?: {
-        readonly id: string;
-        readonly tag?: string;
-        setActivity?(name: string, options?: {
-            type?: number;
-            url?: string;
-        }): void;
-    } | null;
-    channels: {
-        fetch(id: string): Promise<{
-            id: string;
-            type: number;
-            isTextBased(): boolean;
-            send?(options: MessageCreateOptions): Promise<{
-                id: string;
-            }>;
-            messages?: {
-                fetch(id: string): Promise<{
-                    delete(): Promise<unknown>;
-                    react(emoji: string): Promise<unknown>;
-                    reactions: {
-                        resolve(emoji: unknown): {
-                            users: {
-                                remove(userId: string): Promise<unknown>;
-                            };
-                        } | null;
-                        cache: {
-                            find(fn: (r: {
-                                emoji: {
-                                    toString(): string;
-                                    name?: string | null;
-                                    id?: string | null;
-                                };
-                            }) => boolean): {
-                                users: {
-                                    remove(userId: string): Promise<unknown>;
-                                };
-                            } | undefined;
-                        };
-                    };
-                }>;
-            };
-            threads?: {
-                create(options: Record<string, unknown>): Promise<{
-                    id: string;
-                }>;
-            };
-            availableTags?: Array<{
-                id: string;
-                name: string;
-            }>;
-        } | null>;
-    };
-    guilds: {
-        fetch(id: string): Promise<{
-            id: string;
-            name: string;
-            ownerId: string;
-            memberCount: number;
-            createdAt?: Date | null;
-            iconURL?(options?: {
-                size?: number;
-            }): string | null;
-            roles: {
-                fetch(): Promise<unknown>;
-                cache: Map<string, {
-                    id: string;
-                    name: string;
-                    hexColor: string;
-                    position: number;
-                    permissions: {
-                        bitfield: bigint;
-                    };
-                }> | {
-                    map(fn: (role: {
-                        id: string;
-                        name: string;
-                        hexColor: string;
-                        position: number;
-                        permissions: {
-                            bitfield: bigint;
-                        };
-                    }) => unknown): unknown[];
-                };
-            };
-            members: {
-                fetch(userId: string | {
-                    limit?: number;
-                }): Promise<unknown>;
-                ban(userId: string, options?: {
-                    reason?: string;
-                    deleteMessageSeconds?: number;
-                }): Promise<unknown>;
-                unban(userId: string, reason?: string): Promise<unknown>;
-            };
-        }>;
-        cache: {
-            values(): IterableIterator<{
-                id: string;
-                name: string;
-                channels: {
-                    cache: {
-                        values(): IterableIterator<{
-                            id: string;
-                            name?: string;
-                            type: number;
-                        }>;
-                    };
-                };
-            }>;
-        };
-    };
-}
-export type CreateDiscordClient = (intents: readonly number[], gatewayFaultProxyUrl?: string, restOptions?: Partial<RESTOptions>) => DiscordClientTransport;
-export declare function defaultCreateClient(intents: readonly number[], gatewayFaultProxyUrl?: string, restOptions?: Partial<RESTOptions>): DiscordClientTransport;
+/** Native SDK surface; tests inject transport below the Client rather than replacing its identity. */
+export type DiscordClientTransport = Client;
+export declare function discordClientOptions(intents: readonly number[], gatewayFaultProxyUrl?: string, restOptions?: Partial<RESTOptions>): ClientOptions;
 export declare function resolveSenderRole(msg: DiscordInboundMessage): string | undefined;
 export declare function normalizeDiscordMessage(raw: unknown): DiscordInboundMessage | null;
 export declare function toMessageCreateOptions(body: DiscordOutboundBody): Promise<MessageCreateOptions>;
 export interface DiscordGatewayConnectHandlers {
+    readonly receive: EndpointEventSink['run'];
     onPlatformEvent(name: string, event: unknown): void;
     onMessage(msg: DiscordInboundMessage): void;
     onButton(interaction: DiscordButtonInbound): void;

package/lib/gateway.js

@@ -1,7 +1,7 @@
 import { DiscordFaultProxyStrategy } from './gateway-fault-proxy.js';
-import { createReadStream, promises as fs } from 'node:fs';
+import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { Client, Partials, GatewayIntentBits, EmbedBuilder, AttachmentBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, REST, Routes, PermissionFlagsBits, } from 'discord.js';
+import { Partials, GatewayIntentBits, EmbedBuilder, AttachmentBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle, REST, Routes, PermissionFlagsBits, } from 'discord.js';
 import { formatCompact, getLogger } from '@zhin.js/logger';
 import { activityTypeCode, resolveChannelKind, } from './protocol.js';
 const logger = getLogger('discord');
@@ -13,8 +13,8 @@ export const DEFAULT_INTENTS = [
     GatewayIntentBits.GuildMembers,
     GatewayIntentBits.GuildMessageReactions,
 ];
-export function defaultCreateClient(intents, gatewayFaultProxyUrl, restOptions = {}) {
-    return new Client({ rest: { ...restOptions, retries: 0, rejectOnRateLimit: () => true }, intents: [...intents], partials: [Partials.Channel], ...(gatewayFaultProxyUrl ? { ws: { buildStrategy: manager => new DiscordFaultProxyStrategy(manager, gatewayFaultProxyUrl) } } : {}) });
+export function discordClientOptions(intents, gatewayFaultProxyUrl, restOptions = {}) {
+    return { rest: { ...restOptions, retries: 0, rejectOnRateLimit: () => true }, intents: [...intents], partials: [Partials.Channel], ...(gatewayFaultProxyUrl ? { ws: { buildStrategy: manager => new DiscordFaultProxyStrategy(manager, gatewayFaultProxyUrl) } } : {}) };
 }
 export function resolveSenderRole(msg) {
     if (msg.isGuildOwner)
@@ -55,6 +55,8 @@ export function normalizeDiscordMessage(raw) {
     }
     return {
         id: msg.id,
+        event: raw,
+        platformSentAt: msg.createdTimestamp,
         content: msg.content ?? '',
         channelId: msg.channel.id,
         channelKind: resolveChannelKind(msg.channel.type),
@@ -120,7 +122,7 @@ export async function toMessageCreateOptions(body) {
                 }));
             }
             else if (file.file && await fileExists(file.file)) {
-                files.push(new AttachmentBuilder(createReadStream(file.file), {
+                files.push(new AttachmentBuilder(file.file, {
                     name: file.name || path.basename(file.file),
                 }));
             }
@@ -211,70 +213,81 @@ export async function connectDiscordGatewayClient(client, config, handlers, sign
         signal?.addEventListener('abort', onAbort, { once: true });
         const releaseAbort = () => signal?.removeEventListener('abort', onAbort);
         client.on('messageCreate', (raw) => {
-            handlers.onPlatformEvent('messageCreate', raw);
-            const msg = normalizeDiscordMessage(raw);
-            if (!msg)
-                return;
-            // clientReady 之后 client.user 一定可用；消息事件只会在此之后到达
-            const botId = client.user?.id;
-            const mentions = raw.mentions;
-            const mentionedBot = !!botId && mentions?.users?.has?.(botId) === true;
-            handlers.onMessage(mentionedBot ? { ...msg, mentionedBot: true } : msg);
+            void handlers.receive(() => {
+                handlers.onPlatformEvent('messageCreate', raw);
+                const msg = normalizeDiscordMessage(raw);
+                if (!msg)
+                    return;
+                // clientReady 之后 client.user 一定可用；消息事件只会在此之后到达
+                const botId = client.user?.id;
+                const mentions = raw.mentions;
+                const mentionedBot = !!botId && mentions?.users?.has?.(botId) === true;
+                handlers.onMessage(mentionedBot ? { ...msg, mentionedBot: true } : msg);
+            }).catch(() => logger.debug('Native callback was not admitted'));
         });
         client.on('interactionCreate', (raw) => {
-            handlers.onPlatformEvent('interactionCreate', raw);
-            const interaction = raw;
-            const isButton = interaction.isButton?.() === true;
-            logger.info(formatCompact({ op: 'discord_gateway_interaction_received', button: isButton, cachedChannel: !!interaction.channel, hasChannelId: !!interaction.channelId }));
-            if (!isButton)
-                return;
-            void interaction.deferUpdate?.().then(() => {
-                logger.info(formatCompact({ op: 'discord_gateway_button_ack', status: 'confirmed' }));
-            }).catch(() => {
-                // SDK errors may contain token-bearing callback URLs; log no raw error.
-                logger.warn(formatCompact({ op: 'discord_gateway_button_ack', status: 'failed' }));
-            });
-            const channelId = interaction.channelId ?? interaction.channel?.id;
-            if (!channelId) {
-                logger.warn(formatCompact({ op: 'discord_gateway_button_dropped', reason: 'missing_channel_id' }));
-                return;
-            }
-            handlers.onButton({
-                id: interaction.id,
-                customId: interaction.customId,
-                channelId,
-                channelKind: interaction.channel ? resolveChannelKind(interaction.channel.type) : interaction.guildId ? 'channel' : 'private',
-                ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
-                userId: interaction.user.id,
-                userName: interaction.user.username || interaction.user.displayName || interaction.user.id,
-                sourceMessageId: interaction.message?.id,
-            });
+            void handlers.receive(() => {
+                handlers.onPlatformEvent('interactionCreate', raw);
+                const interaction = raw;
+                const isButton = interaction.isButton?.() === true;
+                logger.info(formatCompact({ op: 'discord_gateway_interaction_received', button: isButton, cachedChannel: !!interaction.channel, hasChannelId: !!interaction.channelId }));
+                if (!isButton)
+                    return;
+                const ack = interaction.deferUpdate?.().then(() => {
+                    logger.info(formatCompact({ op: 'discord_gateway_button_ack', status: 'confirmed' }));
+                }).catch(() => {
+                    // SDK errors may contain token-bearing callback URLs; log no raw error.
+                    logger.warn(formatCompact({ op: 'discord_gateway_button_ack', status: 'failed' }));
+                });
+                const channelId = interaction.channelId ?? interaction.channel?.id;
+                if (!channelId) {
+                    logger.warn(formatCompact({ op: 'discord_gateway_button_dropped', reason: 'missing_channel_id' }));
+                    return ack ? awaitOwnedAck(ack, signal) : undefined;
+                }
+                handlers.onButton({
+                    event: raw,
+                    platformSentAt: raw.createdTimestamp,
+                    id: interaction.id,
+                    customId: interaction.customId,
+                    channelId,
+                    channelKind: interaction.channel ? resolveChannelKind(interaction.channel.type) : interaction.guildId ? 'channel' : 'private',
+                    ...(interaction.guildId ? { guildId: interaction.guildId } : {}),
+                    userId: interaction.user.id,
+                    userName: interaction.user.username || interaction.user.displayName || interaction.user.id,
+                    sourceMessageId: interaction.message?.id,
+                });
+                return ack ? awaitOwnedAck(ack, signal) : undefined;
+            }).catch(() => logger.debug('Native callback was not admitted'));
         });
         client.on('guildMemberAdd', (raw) => {
-            handlers.onPlatformEvent('guildMemberAdd', raw);
-            const member = raw;
-            const guildId = member.guild?.id;
-            const userId = member.user?.id;
-            if (!guildId || !userId)
-                return;
-            handlers.onGuildMemberAdd?.({
-                guildId,
-                userId,
-                userName: member.user?.username || member.user?.displayName,
-            });
+            void handlers.receive(() => {
+                handlers.onPlatformEvent('guildMemberAdd', raw);
+                const member = raw;
+                const guildId = member.guild?.id;
+                const userId = member.user?.id;
+                if (!guildId || !userId)
+                    return;
+                handlers.onGuildMemberAdd?.({
+                    guildId,
+                    userId,
+                    userName: member.user?.username || member.user?.displayName,
+                });
+            }).catch(() => logger.debug('Native callback was not admitted'));
         });
         client.on('guildMemberRemove', (raw) => {
-            handlers.onPlatformEvent('guildMemberRemove', raw);
-            const member = raw;
-            const guildId = member.guild?.id;
-            const userId = member.user?.id;
-            if (!guildId || !userId)
-                return;
-            handlers.onGuildMemberRemove?.({
-                guildId,
-                userId,
-                userName: member.user?.username || member.user?.displayName,
-            });
+            void handlers.receive(() => {
+                handlers.onPlatformEvent('guildMemberRemove', raw);
+                const member = raw;
+                const guildId = member.guild?.id;
+                const userId = member.user?.id;
+                if (!guildId || !userId)
+                    return;
+                handlers.onGuildMemberRemove?.({
+                    guildId,
+                    userId,
+                    userName: member.user?.username || member.user?.displayName,
+                });
+            }).catch(() => logger.debug('Native callback was not admitted'));
         });
         client.once('clientReady', () => {
             if (signal?.aborted)
@@ -334,3 +347,15 @@ export async function connectDiscordGatewayClient(client, config, handlers, sign
         });
     });
 }
+/** Logical cancellation only; the native SDK still owns its already-started ACK. */
+function awaitOwnedAck(operation, signal) {
+    if (!signal)
+        return operation;
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        void operation.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+        if (signal.aborted)
+            abort();
+    });
+}

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 export { activityTypeCode, formatButtonContent, formatInboundContent, formatOutboundBody, resolveChannelKind, resolveDiscordConfig, senderDisplayName, type DiscordActivity, type DiscordEndpointConfig, type DiscordButtonInbound, type DiscordInboundAttachment, type DiscordInboundMessage, type DiscordOutboundBody, type DiscordWireSegment, type ResolvedDiscordConfig, type ResolvedDiscordGatewayConfig, type ResolvedDiscordInteractionsConfig, } from './protocol.js';
-export { discordClient, requireDiscordGatewayClient, type DiscordClient, type DiscordClientEventMap, } from './client.js';
+export { requireDiscordGatewayClient, type DiscordClient, type DiscordClientEventMap, } from './client.js';
 export { checkDiscordPlatformPermit, discordGroupPermitResolver, normalizeDiscordSenderForPermit, platformPermit, } from './platform-permit.js';
-export { DiscordGatewayEndpoint, DiscordInteractionsEndpoint, type CreateDiscordClient, type DiscordClientTransport, type DiscordEndpointOptions, type DiscordInteractionsEndpointOptions, } from './endpoint.js';
-export { connectDiscordGatewayClient, defaultCreateClient, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, type DiscordGatewayConnectHandlers, } from './gateway.js';
+export { DiscordGatewayEndpoint, DiscordInteractionsEndpoint, type DiscordClientTransport, type DiscordEndpointOptions, type DiscordInteractionsEndpointOptions, } from './endpoint.js';
+export { connectDiscordGatewayClient, discordClientOptions, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, type DiscordGatewayConnectHandlers, } from './gateway.js';
 export { handleDiscordInteractionRequest, registerDiscordInteractionRoutes, type DiscordInteractionsHandler, } from './webhook.js';
+export { DiscordAdapter } from './adapter.js';

package/lib/index.js

@@ -1,6 +1,7 @@
 export { activityTypeCode, formatButtonContent, formatInboundContent, formatOutboundBody, resolveChannelKind, resolveDiscordConfig, senderDisplayName, } from './protocol.js';
-export { discordClient, requireDiscordGatewayClient, } from './client.js';
+export { requireDiscordGatewayClient, } from './client.js';
 export { checkDiscordPlatformPermit, discordGroupPermitResolver, normalizeDiscordSenderForPermit, platformPermit, } from './platform-permit.js';
 export { DiscordGatewayEndpoint, DiscordInteractionsEndpoint, } from './endpoint.js';
-export { connectDiscordGatewayClient, defaultCreateClient, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, } from './gateway.js';
+export { connectDiscordGatewayClient, discordClientOptions, normalizeDiscordMessage, resolveSenderRole, toMessageCreateOptions, } from './gateway.js';
 export { handleDiscordInteractionRequest, registerDiscordInteractionRoutes, } from './webhook.js';
+export { DiscordAdapter } from './adapter.js';

package/lib/protocol.d.ts

@@ -56,6 +56,8 @@ export interface DiscordInboundAttachment {
     readonly size?: number;
 }
 export interface DiscordInboundMessage {
+    readonly event?: unknown;
+    readonly platformSentAt?: number;
     readonly id: string;
     readonly content: string;
     readonly channelId: string;
@@ -75,6 +77,8 @@ export interface DiscordInboundMessage {
     readonly mentionedBot?: boolean;
 }
 export interface DiscordButtonInbound {
+    readonly event?: unknown;
+    readonly platformSentAt?: number;
     readonly guildId?: string;
     readonly id: string;
     readonly customId: string;

package/lib/protocol.js

@@ -330,6 +330,7 @@ export function interactionToInboundMessage(interaction) {
     const user = interaction.member?.user
         ?? interaction.user;
     return {
+        event: interaction,
         id: String(interaction.id),
         content: formatSlashCommandContent(interaction),
         channelId: String(interaction.channel_id ?? ''),

package/lib/webhook.d.ts

@@ -1,15 +1,14 @@
+import { type Endpoint } from 'zhin.js/adapter';
 /**
  * Discord interactions HTTP: signature → parse → admit.
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { type Locale } from 'zhin.js/i18n';
 import type { HttpHost, HttpRouteRegistration } from '@zhin.js/host-http';
 import { type DiscordInboundMessage, type DiscordButtonInbound, type ResolvedDiscordInteractionsConfig } from './protocol.js';
-export interface DiscordInteractionsHandler {
+export interface DiscordInteractionsHandler extends Endpoint {
     readonly config: ResolvedDiscordInteractionsConfig;
     readonly isOpen: boolean;
     admit(msg: DiscordInboundMessage): void;
-    resolveLocale?(senderId: string): Promise<Locale | undefined>;
     admitButton(interaction: DiscordButtonInbound): void;
     admitPlatform(event: Record<string, unknown>): void;
 }

package/lib/webhook.js

@@ -1,3 +1,4 @@
+import { endpointSpec } from 'zhin.js/adapter';
 import { createMessages } from 'zhin.js/i18n';
 import { getLogger } from '@zhin.js/logger';
 import { interactionToInboundMessage, verifyDiscordInteractionSignature, } from './protocol.js';
@@ -35,45 +36,56 @@ export async function handleDiscordInteractionRequest(request, response, handler
             return;
         }
         const interaction = JSON.parse(rawBody);
-        if (handler.isOpen)
-            handler.admitPlatform(interaction);
+        if (!interaction || interaction.application_id !== handler.config.applicationId) {
+            response.writeHead(401, { 'Content-Type': 'text/plain' });
+            response.end('Unauthorized');
+            return;
+        }
+        // A verified protocol challenge is not a business message and keeps its immediate ACK.
         if (interaction.type === INTERACTION_TYPE_PING) {
+            if (handler.isOpen)
+                void handler[endpointSpec].events.run(() => handler.admitPlatform(interaction))
+                    .catch(() => logger.debug('Protocol event dispatch did not complete'));
             writeJson(response, 200, { type: INTERACTION_RESPONSE_PONG });
             return;
         }
-        if (interaction.type === 3) {
-            const data = interaction.data;
-            if (data?.component_type === 2 && typeof data.custom_id === 'string') {
-                if (!handler.isOpen) {
-                    response.writeHead(503);
-                    response.end('Unavailable');
+        await handler[endpointSpec].events.run(async () => {
+            if (handler.isOpen)
+                handler.admitPlatform(interaction);
+            if (interaction.type === 3) {
+                const data = interaction.data;
+                if (data?.component_type === 2 && typeof data.custom_id === 'string') {
+                    if (!handler.isOpen) {
+                        response.writeHead(503);
+                        response.end('Unavailable');
+                        return;
+                    }
+                    const message = interactionToInboundMessage(interaction);
+                    handler.admitButton({ event: interaction, id: message.id, customId: data.custom_id, channelId: message.channelId, channelKind: message.channelKind, userId: message.authorId, userName: message.authorName, ...(message.guildId ? { guildId: message.guildId } : {}), sourceMessageId: interaction.message?.id });
+                    writeJson(response, 200, { type: 6 });
                     return;
                 }
+            }
+            if (interaction.type === INTERACTION_TYPE_APPLICATION_COMMAND) {
                 const message = interactionToInboundMessage(interaction);
-                handler.admitButton({ id: message.id, customId: data.custom_id, channelId: message.channelId, channelKind: message.channelKind, userId: message.authorId, userName: message.authorName, ...(message.guildId ? { guildId: message.guildId } : {}), sourceMessageId: interaction.message?.id });
-                writeJson(response, 200, { type: 6 });
+                if (handler.isOpen) {
+                    handler.admit(message);
+                }
+                const locale = await handler[endpointSpec].resolveLocale(message.authorId);
+                // 即时响应（type 4）：defer(type 5) 需要 followup PATCH，未实现会让用户端一直转圈
+                const commandName = String(interaction.data?.name ?? '');
+                writeJson(response, 200, {
+                    type: INTERACTION_RESPONSE_CHANNEL_MESSAGE_WITH_SOURCE,
+                    data: {
+                        content: messages(locale, 'processing', { command: commandName }),
+                        flags: INTERACTION_FLAG_EPHEMERAL,
+                    },
+                });
                 return;
             }
-        }
-        if (interaction.type === INTERACTION_TYPE_APPLICATION_COMMAND) {
-            const message = interactionToInboundMessage(interaction);
-            if (handler.isOpen) {
-                handler.admit(message);
-            }
-            const locale = await handler.resolveLocale?.(message.authorId);
-            // 即时响应（type 4）：defer(type 5) 需要 followup PATCH，未实现会让用户端一直转圈
-            const commandName = String(interaction.data?.name ?? '');
-            writeJson(response, 200, {
-                type: INTERACTION_RESPONSE_CHANNEL_MESSAGE_WITH_SOURCE,
-                data: {
-                    content: messages(locale, 'processing', { command: commandName }),
-                    flags: INTERACTION_FLAG_EPHEMERAL,
-                },
-            });
-            return;
-        }
-        response.writeHead(400, { 'Content-Type': 'text/plain' });
-        response.end('Unsupported interaction type');
+            response.writeHead(400, { 'Content-Type': 'text/plain' });
+            response.end('Unsupported interaction type');
+        });
     }
     catch (error) {
         logger.error('Discord interactions error:', error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zhin.js/adapter-discord",
-  "version": "1.1.18",
+  "version": "1.1.20",
   "description": "Zhin.js Discord adapter for Plugin Runtime (Gateway WebSocket)",
   "type": "module",
   "main": "./lib/index.js",
@@ -35,26 +35,26 @@
     "@discordjs/ws": "1.2.3",
     "discord.js": "^14.27.0",
     "undici": "6.29.1",
-    "@zhin.js/adapter": "1.1.25",
-    "@zhin.js/agent-feature": "1.1.10",
-    "@zhin.js/client": "1.1.21",
+    "@zhin.js/adapter": "1.1.26",
+    "@zhin.js/agent-feature": "1.1.11",
+    "@zhin.js/client": "1.1.22",
     "@zhin.js/console-contract": "1.1.3",
-    "@zhin.js/core": "1.1.53",
-    "@zhin.js/feature-kit": "1.1.9",
-    "@zhin.js/host-http": "1.1.11",
+    "@zhin.js/core": "1.1.54",
+    "@zhin.js/feature-kit": "1.1.10",
+    "@zhin.js/host-http": "1.1.12",
     "@zhin.js/im-contract": "1.1.9",
     "@zhin.js/logger": "1.1.2",
-    "@zhin.js/page": "1.1.10",
-    "@zhin.js/permission": "1.1.9",
-    "@zhin.js/skill": "1.1.10",
-    "@zhin.js/tool": "1.1.12"
+    "@zhin.js/page": "1.1.12",
+    "@zhin.js/permission": "1.1.10",
+    "@zhin.js/skill": "1.1.11",
+    "@zhin.js/tool": "1.1.13"
   },
   "peerDependencies": {
     "zod": "^4.0.0",
-    "@zhin.js/adapter": "^1.1.25",
-    "@zhin.js/command": "^1.1.11",
-    "@zhin.js/core": "^1.1.53",
-    "zhin.js": "^1.1.18"
+    "@zhin.js/adapter": "^1.1.26",
+    "@zhin.js/command": "^1.1.12",
+    "@zhin.js/core": "^1.1.54",
+    "zhin.js": "^1.1.19"
   },
   "peerDependenciesMeta": {
     "@zhin.js/command": {
@@ -72,8 +72,8 @@
     "typescript": "^6.0.3",
     "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "@zhin.js/host-http": "1.1.11",
-    "zhin.js": "1.1.18"
+    "@zhin.js/host-http": "1.1.12",
+    "zhin.js": "1.1.19"
   },
   "files": [
     "adapters",
@@ -104,7 +104,7 @@
     "features": [
       {
         "package": "@zhin.js/adapter",
-        "api": "^1.0.0"
+        "api": "^2.0.0"
       },
       {
         "package": "@zhin.js/command",

package/plugin.js

@@ -1,9 +1,7 @@
 // Generated by build-plugin-runtime-entries.mjs. Do not edit.
-import { createEndpointRuntimeState } from 'zhin.js/adapter';
 import { definePlugin, pluginConsoleRpcToken } from 'zhin.js';
 import { permissionHostToken } from '@zhin.js/permission';
 import { checkDiscordPlatformPermit } from "./lib/platform-permit.js";
-import { discordRuntimeStateToken } from "./lib/discord-runtime-state.js";
 import { createDiscordConsoleRpc } from "./lib/console.js";
 export default definePlugin({
     name: 'discord',
@@ -11,8 +9,7 @@ export default definePlugin({
         displayName: 'Discord Gateway Adapter',
     },
     setup(context) {
-        context.resources.provide(discordRuntimeStateToken, createEndpointRuntimeState());
-        context.resources.provide(pluginConsoleRpcToken, createDiscordConsoleRpc(context.resources, () => context.config.get()));
+        context.resources.provide(pluginConsoleRpcToken, createDiscordConsoleRpc(() => context.config.get()));
         if (context.resources.has(permissionHostToken)) {
             const host = context.resources.use(permissionHostToken);
             return host.registerPlatform('discord', checkDiscordPlatformPermit);

package/src/adapter.ts

@@ -0,0 +1,38 @@
+import { Adapter, type AdapterContext, type EndpointCreationContext } from 'zhin.js/adapter';
+import { httpHostToken } from '@zhin.js/host-http';
+import { REST, Routes } from 'discord.js';
+import { DiscordGatewayEndpoint, DiscordInteractionsEndpoint } from './endpoint.js';
+import { createDiscordRestApiAgent } from './rest-api-proxy.js';
+import { resolveDiscordConfig, type DiscordEndpointConfig } from './protocol.js';
+import type { DiscordClientEventMap } from './client.js';
+
+export class DiscordAdapter extends Adapter<DiscordGatewayEndpoint | DiscordInteractionsEndpoint, DiscordEndpointConfig, DiscordClientEventMap> {
+  constructor(private readonly context: AdapterContext<DiscordEndpointConfig>) { super(); }
+  override get configurationIdentityFields(): readonly string[] { return ['id', 'applicationId']; }
+  override get configurationIdentityProbeFields(): readonly string[] { return ['token', 'publicKey']; }
+  override get configurationUpdateFields(): readonly string[] { return ['token', 'connection', 'restApiProxy', 'restApiProxy.port',
+    'gatewayFaultProxyUrl', 'intents', 'defaultActivity', 'defaultActivity.name', 'defaultActivity.type', 'defaultActivity.url', 'publicKey', 'interactionsPath']; }
+  protected override validateConfiguration(input: DiscordEndpointConfig): void { resolveDiscordConfig(input); }
+  protected override async identifyConfiguration(input: DiscordEndpointConfig, signal: AbortSignal): Promise<string> {
+    const config = resolveDiscordConfig(input);
+    const agent = config.connection === 'gateway' && config.restApiProxy ? createDiscordRestApiAgent(config.restApiProxy) : undefined;
+    const rest = new REST({ version: '10', retries: 0, rejectOnRateLimit: () => true, ...(agent ? { agent } : {}) }).setToken(config.token);
+    try {
+      const application = await rest.get(Routes.currentApplication(), { signal }) as { id?: unknown; verify_key?: unknown };
+      if (typeof application?.id !== 'string' || !application.id.trim()) throw new Error('Discord identity response is incomplete');
+      if (config.connection === 'interactions' && application.id !== config.applicationId) throw new Error('Discord application identity configuration does not match');
+      if (config.connection === 'interactions' && (typeof application.verify_key !== 'string'
+        || application.verify_key.toLowerCase() !== config.publicKey.toLowerCase())) {
+        throw new Error('Discord verification key does not match the application identity');
+      }
+      return JSON.stringify(['discord', application.id]);
+    } finally { rest.clearHashSweeper(); rest.clearHandlerSweeper(); await agent?.destroyProxy(); }
+  }
+  protected async createEndpoint(input: DiscordEndpointConfig, execution: EndpointCreationContext): Promise<DiscordGatewayEndpoint | DiscordInteractionsEndpoint> {
+    const config = resolveDiscordConfig(input);
+    if (config.connection === 'interactions') return new DiscordInteractionsEndpoint({ id: execution.canonicalId, config, http: this.context.use(httpHostToken) });
+    const restApiAgent = config.restApiProxy ? createDiscordRestApiAgent(config.restApiProxy) : undefined;
+    try { return new DiscordGatewayEndpoint({ id: execution.canonicalId, config, restApiAgent }); }
+    catch (error) { await restApiAgent?.destroyProxy(); throw error; }
+  }
+}