@zhin.js/adapter-slack 1.1.18 → 1.1.19

package/lib/endpoint.js

@@ -1,12 +1,12 @@
 /**
  * SlackEndpoint — lifecycle, outbound, admit, Socket Mode, agent tool surface.
  */
+import { WebClient } from '@slack/web-api';
 import { SocketModeClient } from '@slack/socket-mode';
-import { createSlackWebApiAgent } from './web-api-proxy.js';
 import { createSlackStreamAgent } from './stream-proxy.js';
 import { slackSocketConnectionError } from './socket-error.js';
-import { createSlackWebClient, slackDeliveryError } from './web-client.js';
-import { Endpoint, createEndpointLifecycle, } from 'zhin.js/adapter';
+import { slackWebClientOptions, slackDeliveryError } from './web-client.js';
+import { createEndpointSpecification, endpointSpec, createEndpointLifecycle, createEndpointOperation, } from 'zhin.js/adapter';
 import { formatCompact, getAdapterLogger } from '@zhin.js/logger';
 import { formatInboundContent, formatInteractionContent, formatSlashContent, resolveSlackChannelType, slackInboundConversation, } from './protocol.js';
 import { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
@@ -16,81 +16,79 @@ import { postSlackEphemeral } from './slack-response-url.js';
 import { editSlackContent, sendSlackContent } from './slack-outbound.js';
 import { registerSlackWebhookRoutes } from './webhook.js';
 import { receiveSlackSideEvent } from './side-event-dispatch.js';
-export class SlackEndpoint extends Endpoint {
+export class SlackEndpoint extends WebClient {
+    [endpointSpec];
     #logger;
     #options;
     #inboundFilter = createSlackInboundFilterState();
     #messageChannelMap = new Map();
-    #client;
-    #webApiAgent;
     #socket;
     #lifecycle;
     #routeReleases = [];
     #botUserId;
-    #open = false;
+    #executionSignal;
     #started = false;
-    management = createSlackEndpointManagement(() => this.client);
-    control = Object.freeze({
-        recall: async (message) => {
+    #management = createSlackEndpointManagement(() => this);
+    #control = Object.freeze({
+        recall: async ({ message, signal }) => {
             const ref = this.resolveMessageRef(message.id, message.conversation.id);
-            if (!ref || !this.#client)
+            if (!ref || !this.#started)
                 return;
-            await this.#client.chat.delete(ref);
+            await createEndpointOperation({ signal }).run(() => this.chat.delete(ref));
         },
-        edit: async (message, content) => {
+        edit: async ({ message, content, signal }) => {
             const ref = this.resolveMessageRef(message.id, message.conversation.id);
             if (!ref)
                 return null;
-            await this.#editMessage(ref.channel, ref.ts, content);
+            await this.#editMessage({ channel: ref.channel, ts: ref.ts, content, signal });
             return message.id;
         },
-        addReaction: async (message, emoji) => {
+        addReaction: async ({ message, emoji, signal }) => {
             const ref = this.resolveMessageRef(message.id, message.conversation.id);
             if (!ref)
                 return null;
             const reaction = normalizeSlackReactionName(emoji);
-            await this.#addReaction(ref.channel, ref.ts, reaction);
+            await this.#addReaction({ channel: ref.channel, timestamp: ref.ts, name: reaction, signal });
             return reaction;
         },
-        removeReaction: async (message, reactionId) => {
+        removeReaction: async ({ message, reactionId, signal }) => {
             const ref = this.resolveMessageRef(message.id, message.conversation.id);
             if (!ref)
                 return;
-            await this.#removeReaction(ref.channel, ref.ts, reactionId);
+            await this.#removeReaction({ channel: ref.channel, timestamp: ref.ts, name: reactionId, signal });
         },
     });
     constructor(options) {
-        super();
+        super(options.config.token, slackWebClientOptions({ ...options.webOptions, ...(options.webApiAgent ? { agent: options.webApiAgent } : {}) }));
         this.#logger = getAdapterLogger('slack', options.config.id);
         this.#options = options;
         this.#lifecycle = createEndpointLifecycle({ name: options.config.id });
+        const endpoint = this;
+        this[endpointSpec] = createEndpointSpecification(this, {
+            start: signal => this.#startFramework(signal), open: () => undefined, close: () => undefined,
+            stop: () => this.#stopFramework(), send: request => this.#sendFramework(request),
+            name: options.config.id, get transportState() { return endpoint.#transportState; },
+            management: this.#management, control: this.#control,
+        });
     }
     /** Console 展示 / AdapterIndex live name（多 endpoint 时与 entry name 一致）。 */
     get name() {
         return this.#options.config.id;
     }
-    get client() {
-        if (!this.#client)
-            throw new Error('Slack client not connected');
-        return this.#client;
-    }
-    get transportState() { return this.config.mode === 'socket' ? this.#lifecycle.state : this.#started ? 'open' : 'stopped'; }
+    get #transportState() { return this.config.mode === 'socket' ? this.#lifecycle.state : this.#started ? 'open' : 'stopped'; }
     get platformUserId() {
         return this.#botUserId;
     }
     get config() {
         return this.#options.config;
     }
-    async start() {
+    async #startFramework(signal) {
+        this.#executionSignal = signal;
         if (this.#started)
             return;
         this.#started = true;
         try {
             const { config } = this.#options;
-            if (config.webApiProxy && !this.#options.createClient)
-                this.#webApiAgent = createSlackWebApiAgent(config.webApiProxy);
-            this.#client = this.#options.createClient?.(config.token)
-                ?? createSlackWebClient(config.token, this.#webApiAgent ? { agent: this.#webApiAgent } : {});
             if (config.mode === 'socket') {
                 await this.#startSocket();
             }
@@ -106,28 +104,20 @@ export class SlackEndpoint extends Endpoint {
                     path: config.webhookPath,
                 }));
             }
-            const authTest = await this.#client.auth.test();
+            const authTest = await this.auth.test();
             if (authTest.user_id)
                 this.#botUserId = String(authTest.user_id);
             this.#logger.info(`connected (${config.mode})`
                 + (this.#botUserId ? ` | user: ${this.#botUserId}` : ''));
         }
         catch (error) {
-            await this.stop();
+            await this.#stopFramework();
             this.#logger.error('Failed to connect Slack endpoint:', error);
             throw error;
         }
     }
-    open() {
-        this.#open = true;
-    }
-    close() {
-        this.#open = false;
-    }
-    async stop() {
-        this.#open = false;
-        this.#webApiAgent?.destroy();
-        this.#webApiAgent = undefined;
+    async #stopFramework() {
+        this.#options.webApiAgent?.destroy();
         await this.#lifecycle.stop();
         if (this.#socket) {
             try {
@@ -140,17 +130,16 @@ export class SlackEndpoint extends Endpoint {
         }
         for (const release of this.#routeReleases.splice(0))
             release();
-        this.#client = undefined;
         this.#started = false;
         this.#logger.debug(formatCompact({ op: 'disconnect' }));
     }
-    async send({ conversation, payload }) {
-        if (!this.#client)
+    async #sendFramework({ conversation, payload, signal }) {
+        if (!this.#started)
             throw new Error('Slack client not connected');
         const channel = conversation.id;
         const threadTs = conversation.threadId;
         try {
-            const result = await sendSlackContent(this.#client, payload, { channel, threadTs }, this.#logger);
+            const result = await sendSlackContent(this, { content: payload, channel, threadTs, logger: this.#logger, signal });
             this.trackMessageChannel(result.ts, channel);
             return formatSlackMessageRef(channel, result.ts);
         }
@@ -159,123 +148,131 @@ export class SlackEndpoint extends Endpoint {
         }
     }
     /** Test / internal: admit a message event when open. */
-    admit(event) {
-        if (!this.#open)
-            return;
-        void this.#emitPlatformEvent(event.type || 'event', event);
-        if (event.type !== 'message' && event.type !== 'app_mention')
-            return;
-        const msg = event;
-        if (shouldDropSlackInboundMessage(msg, this.#inboundFilter, this.#botUserId))
-            return;
-        if (!msg.channel || !msg.ts)
-            return;
-        this.trackMessageChannel(msg.ts, msg.channel);
-        const threadTs = msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : undefined;
-        const conversation = slackInboundConversation(String(this.#options.id), {
-            channelId: msg.channel,
-            channelType: msg.channel_type,
-            threadId: threadTs,
-        });
-        void this.emit('message.receive', {
-            conversation,
-            message: { conversation, id: msg.ts },
-            content: formatInboundContent(msg),
-            sender: { id: msg.user ?? msg.channel ?? '' },
-            endpointId: this.#options.config.id,
-            ...(msg.type === 'app_mention' ? { mentioned: true } : {}),
-            metadata: Object.freeze({
-                channelType: resolveSlackChannelType(msg),
-                userId: msg.user,
-                threadTs,
-                ts: msg.ts,
-            }),
-        }).catch((err) => {
-            this.#logger.warn(formatCompact({
-                op: 'slack_gateway_receive_failed',
-                target: `${conversation.kind}:${conversation.id}`,
-                error: err instanceof Error ? err.message : String(err),
-            }));
-        });
+    admit(event, original = event) {
+        void this[endpointSpec].events.run(() => {
+            void this.#emitPlatformEvent(event.type || 'event', event);
+            if (event.type !== 'message' && event.type !== 'app_mention')
+                return;
+            const msg = event;
+            if (shouldDropSlackInboundMessage(msg, this.#inboundFilter, this.#botUserId))
+                return;
+            if (!msg.channel || !msg.ts)
+                return;
+            this.trackMessageChannel(msg.ts, msg.channel);
+            const threadTs = msg.thread_ts && msg.thread_ts !== msg.ts ? msg.thread_ts : undefined;
+            const conversation = slackInboundConversation(String(this.#options.id), {
+                channelId: msg.channel,
+                channelType: msg.channel_type,
+                threadId: threadTs,
+            });
+            void this[endpointSpec].events.emit('message.receive', {
+                conversation,
+                event: original,
+                ...(typeof msg.ts === 'string' && Number.isFinite(Number(msg.ts)) ? { platformSentAt: Number(msg.ts) * 1_000 } : {}),
+                message: { conversation, id: msg.ts },
+                content: formatInboundContent(msg),
+                sender: { id: msg.user ?? msg.channel ?? '' },
+                endpointId: this.#options.config.id,
+                ...(msg.type === 'app_mention' ? { mentioned: true } : {}),
+                metadata: Object.freeze({
+                    channelType: resolveSlackChannelType(msg),
+                    userId: msg.user,
+                    threadTs,
+                    ts: msg.ts,
+                }),
+            }).catch((err) => {
+                this.#logger.warn(formatCompact({
+                    op: 'slack_gateway_receive_failed',
+                    target: `${conversation.kind}:${conversation.id}`,
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            });
+        }).catch(() => this.#logger.debug('Inbound callback did not complete'));
     }
     admitInteraction(payload) {
-        if (!this.#open)
-            return;
-        void this.#emitPlatformEvent(`interaction.${payload.type}`, payload);
-        if (payload.type !== 'block_actions' || !payload.actions?.length)
-            return;
-        const channelId = payload.channel?.id ?? '';
-        const userId = payload.user.id;
-        const messageTs = payload.message?.ts ?? '';
-        const sourceThread = payload.message?.thread_ts;
-        const threadTs = typeof sourceThread === 'string' && sourceThread && sourceThread !== messageTs ? sourceThread : undefined;
-        if (payload.response_url) {
-            postSlackEphemeral(payload.response_url, '已收到', this.#logger);
-        }
-        const actionTs = payload.actions[0]?.action_ts ?? messageTs ?? `action-${Date.now()}`;
-        const conversation = slackInboundConversation(String(this.#options.id), {
-            channelId: channelId || userId,
-            // block_actions 无 channel_type；无 channel 时按与发起用户的 DM 处理
-            channelType: channelId ? undefined : 'im',
-            threadId: threadTs,
-        });
-        void this.emit('message.receive', {
-            conversation,
-            message: { conversation, id: actionTs },
-            content: formatInteractionContent(payload),
-            segments: [{ type: 'action', data: { id: actionTs, payload: payload.actions[0].value ?? payload.actions[0].action_id, ...(messageTs ? { sourceMessageId: messageTs } : {}) } }],
-            sender: { id: userId },
-            endpointId: this.#options.config.id,
-            metadata: Object.freeze({
-                eventType: 'block_actions',
-                actionId: payload.actions[0]?.action_id,
-                threadTs,
-            }),
-        }).catch((err) => {
-            this.#logger.warn(formatCompact({
-                op: 'slack_gateway_receive_failed',
-                target: `${conversation.kind}:${conversation.id}`,
-                error: err instanceof Error ? err.message : String(err),
-            }));
-        });
+        void this[endpointSpec].events.run(() => {
+            void this.#emitPlatformEvent(`interaction.${payload.type}`, payload);
+            if (payload.type !== 'block_actions' || !payload.actions?.length)
+                return;
+            const channelId = payload.channel?.id ?? '';
+            const userId = payload.user.id;
+            const messageTs = payload.message?.ts ?? '';
+            const sourceThread = payload.message?.thread_ts;
+            const threadTs = typeof sourceThread === 'string' && sourceThread && sourceThread !== messageTs ? sourceThread : undefined;
+            if (payload.response_url) {
+                postSlackEphemeral(payload.response_url, '已收到', this.#logger);
+            }
+            const actionTs = payload.actions[0]?.action_ts ?? messageTs ?? `action-${Date.now()}`;
+            const platformSentAt = Number(payload.actions[0]?.action_ts) * 1_000;
+            const conversation = slackInboundConversation(String(this.#options.id), {
+                channelId: channelId || userId,
+                // block_actions 无 channel_type；无 channel 时按与发起用户的 DM 处理
+                channelType: channelId ? undefined : 'im',
+                threadId: threadTs,
+            });
+            void this[endpointSpec].events.emit('message.receive', {
+                conversation,
+                event: payload,
+                ...(Number.isFinite(platformSentAt) ? { platformSentAt } : {}),
+                message: { conversation, id: actionTs },
+                content: formatInteractionContent(payload),
+                segments: [{ type: 'action', data: { id: actionTs, payload: payload.actions[0].value ?? payload.actions[0].action_id, ...(messageTs ? { sourceMessageId: messageTs } : {}) } }],
+                sender: { id: userId },
+                endpointId: this.#options.config.id,
+                metadata: Object.freeze({
+                    eventType: 'block_actions',
+                    actionId: payload.actions[0]?.action_id,
+                    threadTs,
+                }),
+            }).catch((err) => {
+                this.#logger.warn(formatCompact({
+                    op: 'slack_gateway_receive_failed',
+                    target: `${conversation.kind}:${conversation.id}`,
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            });
+        }).catch(() => this.#logger.debug('Inbound callback did not complete'));
     }
     admitSlashCommand(cmd) {
-        if (!this.#open)
-            return;
-        void this.#emitPlatformEvent(`slash.${cmd.command}`, cmd);
-        postSlackEphemeral(cmd.response_url, '处理中…', this.#logger);
-        const conversation = slackInboundConversation(String(this.#options.id), {
-            channelId: cmd.channel_id,
-        });
-        void this.emit('message.receive', {
-            conversation,
-            message: { conversation, id: cmd.trigger_id },
-            content: formatSlashContent(cmd),
-            sender: { id: cmd.user_id, name: cmd.user_name },
-            endpointId: this.#options.config.id,
-            metadata: Object.freeze({
-                eventType: 'slash_command',
-                command: cmd.command,
-            }),
-        }).catch((err) => {
-            this.#logger.warn(formatCompact({
-                op: 'slack_gateway_receive_failed',
-                target: `${conversation.kind}:${conversation.id}`,
-                error: err instanceof Error ? err.message : String(err),
-            }));
-        });
+        void this[endpointSpec].events.run(() => {
+            void this.#emitPlatformEvent(`slash.${cmd.command}`, cmd);
+            postSlackEphemeral(cmd.response_url, '处理中…', this.#logger);
+            const conversation = slackInboundConversation(String(this.#options.id), {
+                channelId: cmd.channel_id,
+            });
+            void this[endpointSpec].events.emit('message.receive', {
+                conversation,
+                message: { conversation, id: cmd.trigger_id },
+                event: cmd,
+                content: formatSlashContent(cmd),
+                sender: { id: cmd.user_id, name: cmd.user_name },
+                endpointId: this.#options.config.id,
+                metadata: Object.freeze({
+                    eventType: 'slash_command',
+                    command: cmd.command,
+                }),
+            }).catch((err) => {
+                this.#logger.warn(formatCompact({
+                    op: 'slack_gateway_receive_failed',
+                    target: `${conversation.kind}:${conversation.id}`,
+                    error: err instanceof Error ? err.message : String(err),
+                }));
+            });
+        }).catch(() => this.#logger.debug('Inbound callback did not complete'));
     }
     handleEnvelope(body) {
-        const envelope = body;
-        if (envelope?.type === 'event_callback' && envelope.event) {
-            const event = envelope.event;
-            if (event.type !== 'message' && event.type !== 'app_mention') {
-                void this.#emitPlatformEvent(event.type || 'event', event);
-                receiveSlackSideEvent((name, payload) => this.emit(name, payload), String(this.#options.id), this.#options.config.id, event, this.#logger);
-                return;
+        void this[endpointSpec].events.run(() => {
+            const envelope = body;
+            if (envelope?.type === 'event_callback' && envelope.event) {
+                const event = envelope.event;
+                if (event.type !== 'message' && event.type !== 'app_mention') {
+                    void this.#emitPlatformEvent(event.type || 'event', event);
+                    receiveSlackSideEvent((name, payload) => this[endpointSpec].events.emit(name, payload), String(this.#options.id), this.#options.config.id, event, this.#logger);
+                    return;
+                }
+                this.admit(event, body);
             }
-            this.admit(event);
-        }
+        }).catch(() => this.#logger.debug('Inbound callback did not complete'));
     }
     trackMessageChannel(ts, channel) {
         if (!ts || !channel)
@@ -302,22 +299,22 @@ export class SlackEndpoint extends Endpoint {
         return channel ? { channel, ts: messageId } : null;
     }
     async recallMessage(messageId) {
-        if (!this.#client)
+        if (!this.#started)
             return;
         const ref = this.resolveMessageRef(messageId);
         if (!ref)
             return;
-        await this.#client.chat.delete({ channel: ref.channel, ts: ref.ts });
+        await this.chat.delete({ channel: ref.channel, ts: ref.ts });
     }
-    async #editMessage(channel, messageTs, content) {
-        if (!this.#client)
+    async #editMessage(request) {
+        if (!this.#started)
             throw new Error('Slack client not connected');
-        await editSlackContent(this.#client, channel, messageTs, content);
+        await editSlackContent(this, request);
     }
-    async #addReaction(channel, timestamp, name) {
+    async #addReaction({ channel, timestamp, name, signal }) {
         const reaction = normalizeSlackReactionName(name);
         try {
-            await this.#client.reactions.add({ channel, timestamp, name: reaction });
+            await createEndpointOperation({ signal }).run(() => this.reactions.add({ channel, timestamp, name: reaction }));
         }
         catch (error) {
             const code = error?.data?.error;
@@ -326,10 +323,10 @@ export class SlackEndpoint extends Endpoint {
             throw error;
         }
     }
-    async #removeReaction(channel, timestamp, name) {
+    async #removeReaction({ channel, timestamp, name, signal }) {
         const reaction = normalizeSlackReactionName(name);
         try {
-            await this.#client.reactions.remove({ channel, timestamp, name: reaction });
+            await createEndpointOperation({ signal }).run(() => this.reactions.remove({ channel, timestamp, name: reaction }));
         }
         catch (error) {
             const code = error?.data?.error;
@@ -339,7 +336,7 @@ export class SlackEndpoint extends Endpoint {
         }
     }
     async #emitPlatformEvent(name, event) {
-        await this.emitPlatform(name, event).catch((error) => {
+        await this[endpointSpec].events.platform(name, event).catch((error) => {
             this.#logger.warn(formatCompact({
                 op: 'slack_platform_event_failed',
                 event: name,
@@ -347,6 +344,18 @@ export class SlackEndpoint extends Endpoint {
             }));
         });
     }
+    #awaitSocketAck(ack) {
+        const signal = this.#executionSignal;
+        if (!signal)
+            return ack;
+        return new Promise((resolve, reject) => {
+            const abort = () => reject(signal.reason);
+            signal.addEventListener('abort', abort, { once: true });
+            void ack.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+            if (signal.aborted)
+                abort();
+        });
+    }
     async #startSocket() {
         const { config } = this.#options;
         if (!config.appToken) {
@@ -371,15 +380,57 @@ export class SlackEndpoint extends Endpoint {
                 return; release(); handle.notifyClosed('Slack socket disconnected'); });
             socket.on('error', error => { connectionError = slackSocketConnectionError(error); if (!active)
                 return; release(); handle.notifyClosed('Slack socket error'); });
-            socket.on('slack_event', async ({ ack, body }) => { if (!active || this.#socket !== socket)
-                return; await ack(); if (active)
-                this.handleEnvelope(body); });
-            socket.on('interactive', async ({ ack, body }) => { if (!active || this.#socket !== socket)
-                return; await ack(); if (active)
-                this.admitInteraction(body); });
-            socket.on('slash_commands', async ({ ack, body }) => { if (!active || this.#socket !== socket)
-                return; await ack(); if (active)
-                this.admitSlashCommand(body); });
+            socket.on('slack_event', ({ ack, body }) => {
+                if (!active || this.#socket !== socket)
+                    return;
+                void this[endpointSpec].events.run(async () => {
+                    try {
+                        await this.#awaitSocketAck(ack());
+                    }
+                    catch (error) {
+                        if (!this.#executionSignal?.aborted)
+                            this.#logger.warn(formatCompact({ op: 'slack_socket_ack_failed' }));
+                        throw error;
+                    }
+                    this.#executionSignal?.throwIfAborted();
+                    if (active)
+                        this.handleEnvelope(body);
+                }).catch(() => this.#logger.debug('Socket callback did not complete'));
+            });
+            socket.on('interactive', ({ ack, body }) => {
+                if (!active || this.#socket !== socket)
+                    return;
+                void this[endpointSpec].events.run(async () => {
+                    try {
+                        await this.#awaitSocketAck(ack());
+                    }
+                    catch (error) {
+                        if (!this.#executionSignal?.aborted)
+                            this.#logger.warn(formatCompact({ op: 'slack_socket_ack_failed' }));
+                        throw error;
+                    }
+                    this.#executionSignal?.throwIfAborted();
+                    if (active)
+                        this.admitInteraction(body);
+                }).catch(() => this.#logger.debug('Socket callback did not complete'));
+            });
+            socket.on('slash_commands', ({ ack, body }) => {
+                if (!active || this.#socket !== socket)
+                    return;
+                void this[endpointSpec].events.run(async () => {
+                    try {
+                        await this.#awaitSocketAck(ack());
+                    }
+                    catch (error) {
+                        if (!this.#executionSignal?.aborted)
+                            this.#logger.warn(formatCompact({ op: 'slack_socket_ack_failed' }));
+                        throw error;
+                    }
+                    this.#executionSignal?.throwIfAborted();
+                    if (active)
+                        this.admitSlashCommand(body);
+                }).catch(() => this.#logger.debug('Socket callback did not complete'));
+            });
             try {
                 await socket.start();
             }
@@ -396,17 +447,18 @@ function createSlackEndpointManagement(requireClient) {
     return Object.freeze({
         // Slack 无"群"概念：public channel 归一为 group（channel 语义由 listChannels 之外省略，
         // Slack channel 本身就是会话载体，避免同一批数据在两个列表里重复）。
-        async listGroups() {
+        async listGroups(request = {}) {
+            const operation = createEndpointOperation(request);
             const client = requireClient();
             const groups = [];
             let cursor;
             do {
-                const page = await client.conversations.list({
+                const page = await operation.run(() => client.conversations.list({
                     types: 'public_channel',
                     exclude_archived: true,
                     limit: SLACK_LIST_PAGE_SIZE,
                     ...(cursor ? { cursor } : {}),
-                });
+                }));
                 for (const value of page.channels ?? []) {
                     const channel = asRecord(value);
                     const id = typeof channel.id === 'string' ? channel.id : '';
@@ -419,15 +471,16 @@ function createSlackEndpointManagement(requireClient) {
             return groups;
         },
         // Slack 无"好友"概念：workspace 成员归一为 friend；nickname 取 real_name 回退 name。
-        async listFriends() {
+        async listFriends(request = {}) {
+            const operation = createEndpointOperation(request);
             const client = requireClient();
             const friends = [];
             let cursor;
             do {
-                const page = await client.users.list({
+                const page = await operation.run(() => client.users.list({
                     limit: SLACK_LIST_PAGE_SIZE,
                     ...(cursor ? { cursor } : {}),
-                });
+                }));
                 for (const value of page.members ?? []) {
                     const user = asRecord(value);
                     const id = typeof user.id === 'string' ? user.id : '';
@@ -445,9 +498,10 @@ function createSlackEndpointManagement(requireClient) {
             return friends;
         },
         // conversations.members 只回 user id 列表（平台形状），逐 user 拉 profile 成本由调用方决定。
-        async listGroupMembers(groupId) {
+        async listGroupMembers({ groupId, signal }) {
+            const operation = createEndpointOperation({ signal });
             const client = requireClient();
-            const result = await client.conversations.members({ channel: groupId });
+            const result = await operation.run(() => client.conversations.members({ channel: groupId }));
             return result.members ?? [];
         },
     });

package/lib/index.d.ts

@@ -1,10 +1,11 @@
 export { formatInboundContent, formatInteractionContent, formatOutboundWire, formatSlashContent, headerValue, keyboardToBlockKitBlocks, normalizeWebhookPath, readTextBody, resolveSlackChannelType, resolveSlackConfig, slackInboundConversation, verifySlackSignature, type ResolvedSlackConfig, type SlackEndpointConfig, type SlackBlockAction, type SlackEvent, type SlackEventEnvelope, type SlackInteractionPayload, type SlackMessageEvent, type SlackSlashCommand, type SlackUrlVerification, type SlackWireSegment, } from './protocol.js';
 export { SlackEndpoint, type SlackEndpointOptions, type SlackSocketLike, type SlackWebClientLike, } from './endpoint.js';
 export { registerSlackWebhookRoutes, handleSlackWebhookRequest, type SlackWebhookHandler, } from './webhook.js';
-export { slackClient, type SlackClientEventMap, type SlackUserInfo, } from './client.js';
+export { type SlackClientEventMap, type SlackUserInfo, } from './client.js';
 export { checkSlackPlatformPermit, normalizeSlackSenderForPermit, platformPermit, slackGroupPermitResolver, } from './platform-permit.js';
 export { normalizeSlackReactionName } from './slack-reaction.js';
 export { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
 export { mrkdwnToMarkdown } from './mrkdwn-to-markdown.js';
 export { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
 export { editSlackContent, sendSlackContent } from './slack-outbound.js';
+export { SlackAdapter } from './adapter.js';

package/lib/index.js

@@ -1,10 +1,10 @@
 export { formatInboundContent, formatInteractionContent, formatOutboundWire, formatSlashContent, headerValue, keyboardToBlockKitBlocks, normalizeWebhookPath, readTextBody, resolveSlackChannelType, resolveSlackConfig, slackInboundConversation, verifySlackSignature, } from './protocol.js';
 export { SlackEndpoint, } from './endpoint.js';
 export { registerSlackWebhookRoutes, handleSlackWebhookRequest, } from './webhook.js';
-export { slackClient, } from './client.js';
 export { checkSlackPlatformPermit, normalizeSlackSenderForPermit, platformPermit, slackGroupPermitResolver, } from './platform-permit.js';
 export { normalizeSlackReactionName } from './slack-reaction.js';
 export { markdownToMrkdwn, mrkdwnToPlainFallback, splitMrkdwnText } from './markdown-to-mrkdwn.js';
 export { mrkdwnToMarkdown } from './mrkdwn-to-markdown.js';
 export { createSlackInboundFilterState, shouldDropSlackInboundMessage, } from './slack-inbound-filter.js';
 export { editSlackContent, sendSlackContent } from './slack-outbound.js';
+export { SlackAdapter } from './adapter.js';