@xmanrui/dsh-im 2.4.0 → 2.6.0

package/src/channels/dingtalk/dingtalk-bridge.mjs

@@ -1,4 +1,7 @@
 import {
+  DINGTALK_DONE_REACTION_NAME,
+  DINGTALK_ERROR_REACTION_NAME,
+  DINGTALK_THINKING_REACTION_NAME,
   normalizeDingtalkSessionWebhook,
   splitDingtalkText,
 } from './dingtalk-api.mjs';
@@ -32,6 +35,7 @@ import {
 } from '../shared/batch-input.mjs';
 import {
   hasInboundImages,
+  imagePromptDiagnostic,
   imagePromptUserMessage,
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
@@ -46,10 +50,15 @@ import {
   createDeliveryReceipt,
   providerMessageIdsFor,
 } from '../shared/semantic/delivery.mjs';
+import {
+  channelDeliveryFailure,
+  clearLastMessageFailure,
+  messageFailureText,
+  setLastMessageFailure,
+} from '../shared/message-failure.mjs';
 import { t } from '../shared/i18n.mjs';
 
 const CARD_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
-const CARD_ERROR_TEXT = '消息处理失败，请稍后重试。';
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
 
 const HELP_TEXT_LINES = [
@@ -303,7 +312,15 @@ function canClaimInteractionReply(message, pending, sender) {
 
 function ensureStats(status) {
   status.stats ??= {};
-  for (const key of ['messagesReceived', 'messagesReplied', 'messagesRejected', 'messagesIgnored']) {
+  for (const key of [
+    'messagesReceived',
+    'messagesReplied',
+    'messagesRejected',
+    'messagesIgnored',
+    'reactionsAdded',
+    'reactionsRemoved',
+    'reactionErrors',
+  ]) {
     status[key] ??= 0;
     status.stats[key] = status[key];
   }
@@ -322,16 +339,23 @@ export function createDingtalkBridgeStatus({ pendingSenders = [] } = {}) {
     messagesReplied: 0,
     messagesRejected: 0,
     messagesIgnored: 0,
+    reactionsAdded: 0,
+    reactionsRemoved: 0,
+    reactionErrors: 0,
     lastMessageAt: null,
     lastReplyAt: null,
     lastRejectedAt: null,
     lastError: null,
+    lastMessageError: null,
     pendingSenders: structuredClone(pendingSenders),
     stats: {
       messagesReceived: 0,
       messagesReplied: 0,
       messagesRejected: 0,
       messagesIgnored: 0,
+      reactionsAdded: 0,
+      reactionsRemoved: 0,
+      reactionErrors: 0,
     },
   };
 }
@@ -345,6 +369,7 @@ export class DingtalkHarnessBridge {
   #status;
   #logger;
   #replyTimeoutMs;
+  #reactionTimeoutMs;
   #maxMessageChars;
   #signal;
   #queues = new Map();
@@ -365,6 +390,7 @@ export class DingtalkHarnessBridge {
     status = createDingtalkBridgeStatus(),
     logger = console,
     replyTimeoutMs = 600_000,
+    reactionTimeoutMs = 5_000,
     maxMessageChars = 4_000,
     signal,
   }) {
@@ -382,6 +408,9 @@ export class DingtalkHarnessBridge {
     this.#logger = logger;
     this.#approvals = new HarnessApprovalQueue({ label: 'DingTalk', logger });
     this.#replyTimeoutMs = replyTimeoutMs;
+    this.#reactionTimeoutMs = Number.isFinite(reactionTimeoutMs) && reactionTimeoutMs > 0
+      ? Math.floor(reactionTimeoutMs)
+      : 5_000;
     this.#maxMessageChars = maxMessageChars;
     this.#signal = signal;
     ensureStats(this.#status);
@@ -429,15 +458,35 @@ export class DingtalkHarnessBridge {
     const commandText = nonEmptyString(promptMessage.content) ?? '';
     const addressed = String(message.conversationType) !== '2' || message?.isInAtList === true;
     const direct = String(message.conversationType) !== '2';
+    const statusReaction = sessionWebhook && addressed ? this.#startStatusReaction(message) : null;
+    const finish = (task) => Promise.resolve(task).then(
+      (value) => {
+        this.#finishStatusReaction(
+          statusReaction,
+          this.#signal?.aborted ? 'clear' : 'success',
+        );
+        return value;
+      },
+      (error) => {
+        this.#finishStatusReaction(
+          statusReaction,
+          this.#signal?.aborted || error?.name === 'AbortError' || error?.code === 'turn-stopped'
+            ? 'clear'
+            : 'error',
+        );
+        throw error;
+      },
+    );
     const batchCommand = String(message?.msgtype).toLowerCase() === 'text'
       && isBatchInputCommand(commandText);
     const batchStatus = this.#batchInputs.status(key);
     if (batchCommand && !direct && sessionWebhook && addressed) {
-      return this.#finishBatchResult(
+      return finish(this.#finishBatchResult(
         messageId,
         sessionWebhook,
         { message: batchInputGroupUnsupportedMessage() },
-      );
+        statusReaction,
+      ));
     }
     if (direct && sessionWebhook && (batchCommand || batchStatus.phase === 'collecting')) {
       const exactBatchStart = /^\/batch$/iu.test(commandText);
@@ -453,7 +502,7 @@ export class DingtalkHarnessBridge {
           });
       if (result.handled) {
         if (result.kind === 'submit') {
-          return this.#enqueueMessage(
+          return finish(this.#enqueueMessage(
             {
               ...message,
               msgtype: 'text',
@@ -462,10 +511,15 @@ export class DingtalkHarnessBridge {
             messageId,
             sender,
             key,
-            { batchSubmission: result },
-          );
+            { batchSubmission: result, statusReaction },
+          ));
         }
-        return this.#finishBatchResult(messageId, sessionWebhook, result);
+        return finish(this.#finishBatchResult(
+          messageId,
+          sessionWebhook,
+          result,
+          statusReaction,
+        ));
       }
     }
     const commandRunner = hasInboundFiles(promptMessage) ? null : isControlCommand(commandText)
@@ -483,16 +537,24 @@ export class DingtalkHarnessBridge {
         promptMessage,
         commandRunner,
       ).catch((error) => {
-        if (error?.code === 'turn-stopped' || this.#signal?.aborted) return;
-        this.#status.lastError = t('钉钉命令处理失败。');
-        this.#logger.error?.('[dsh-dingtalk] failed to process a command', safeErrorDiagnostic(error));
-        return this.#send(sessionWebhook, t(CARD_ERROR_TEXT)).catch(() => undefined);
+        if (error?.code === 'turn-stopped' || this.#signal?.aborted) {
+          this.#finishStatusReaction(statusReaction, 'clear');
+          return;
+        }
+        this.#finishStatusReaction(statusReaction, 'error');
+        this.#status.lastError = error?.message ?? String(error);
+        const failure = setLastMessageFailure(this.#status, error);
+        this.#logger.error?.(
+          `[dsh-dingtalk] failed to process a command [${failure.referenceId}]`,
+          safeErrorDiagnostic(error),
+        );
+        return this.#send(sessionWebhook, messageFailureText(failure)).catch(() => undefined);
       }).finally(() => {
         this.#acceptedMessageIds.delete(messageId);
         this.#commandTasks.delete(task);
       });
       this.#commandTasks.add(task);
-      return task;
+      return finish(task);
     }
     const approvalReply = this.#approvals.claimReply({
       key,
@@ -526,7 +588,11 @@ export class DingtalkHarnessBridge {
           return true;
         })
         .catch((error) => {
-          if (this.#signal?.aborted) return;
+          if (this.#signal?.aborted) {
+            this.#finishStatusReaction(statusReaction, 'clear');
+            return;
+          }
+          this.#finishStatusReaction(statusReaction, 'error');
           this.#status.lastError = t('钉钉审批处理失败。');
           this.#logger.error?.('[dsh-dingtalk] failed to process an approval reply', error);
         })
@@ -535,18 +601,18 @@ export class DingtalkHarnessBridge {
           this.#interactionTasks.delete(current);
         });
       this.#interactionTasks.add(current);
-      return current;
+      return finish(current);
     }
 
     if (pending && pending.actor !== sender) {
-      return this.#enqueueMessage(message, messageId, sender, key);
+      return finish(this.#enqueueMessage(message, messageId, sender, key, { statusReaction }));
     }
     // Once one valid answer has been claimed, later messages are subsequent
     // prompts even if the network submission eventually needs a retry. Invalid
     // replies do not claim the question, so the next valid answer can still
     // pass through this interaction queue.
     if (pending?.submitting || pending?.claimedReplyMessageId) {
-      return this.#enqueueMessage(message, messageId, sender, key);
+      return finish(this.#enqueueMessage(message, messageId, sender, key, { statusReaction }));
     }
     if (pending) {
       if (canClaimInteractionReply(message, pending, sender)) {
@@ -555,7 +621,14 @@ export class DingtalkHarnessBridge {
       const previous = pending.queue ?? Promise.resolve();
       const current = previous
         .catch(() => undefined)
-        .then(() => this.#processInteractionReply(message, messageId, sender, key, pending))
+        .then(() => this.#processInteractionReply(
+          message,
+          messageId,
+          sender,
+          key,
+          pending,
+          statusReaction,
+        ))
         .finally(() => {
           this.#acceptedMessageIds.delete(messageId);
           if (pending.claimedReplyMessageId === messageId) {
@@ -564,15 +637,101 @@ export class DingtalkHarnessBridge {
           if (pending.queue === current) pending.queue = null;
         });
       pending.queue = current;
-      return current;
+      return finish(current);
     }
-    return this.#enqueueMessage(message, messageId, sender, key);
+    return finish(this.#enqueueMessage(message, messageId, sender, key, { statusReaction }));
+  }
+
+  #runReactionCall(method, target, reactionName, kind) {
+    const controller = new AbortController();
+    const operation = Promise.resolve().then(() => this.#api[method]({
+      clientId: this.#clientId,
+      clientSecret: this.#clientSecret,
+      ...target,
+      reactionName,
+      signal: controller.signal,
+    }));
+    let timer;
+    const timeout = new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        const error = new DOMException('DingTalk reaction timed out', 'TimeoutError');
+        controller.abort(error);
+        reject(error);
+      }, this.#reactionTimeoutMs);
+      timer.unref?.();
+    });
+    return Promise.race([operation, timeout])
+      .then(() => {
+        increment(this.#status, kind === 'add' ? 'reactionsAdded' : 'reactionsRemoved');
+        return true;
+      })
+      .catch((error) => {
+        increment(this.#status, 'reactionErrors');
+        this.#logger.debug?.(`[dsh-dingtalk] ${method} failed`, safeErrorDiagnostic(error));
+        return false;
+      })
+      .finally(() => clearTimeout(timer));
+  }
+
+  #startStatusReaction(message) {
+    if (typeof this.#api.addReaction !== 'function'
+      || typeof this.#api.recallReaction !== 'function') return null;
+    const messageId = nonEmptyString(message?.msgId);
+    const conversationId = nonEmptyString(message?.conversationId);
+    if (!messageId || !conversationId) return null;
+    const target = {
+      messageId,
+      conversationId,
+      robotCode: nonEmptyString(message?.robotCode) ?? this.#clientId,
+    };
+    return {
+      target,
+      attached: this.#runReactionCall(
+        'addReaction',
+        target,
+        DINGTALK_THINKING_REACTION_NAME,
+        'add',
+      ),
+      terminal: false,
+    };
+  }
+
+  #finishStatusReaction(reaction, outcome) {
+    if (!reaction || reaction.terminal) return;
+    reaction.terminal = true;
+    const terminalName = outcome === 'success'
+      ? DINGTALK_DONE_REACTION_NAME
+      : outcome === 'error' ? DINGTALK_ERROR_REACTION_NAME : null;
+    // Preserve attach -> recall -> terminal ordering without extending the message task.
+    void reaction.attached.then(async (attached) => {
+      let cleaned = await this.#runReactionCall(
+        'recallReaction',
+        reaction.target,
+        DINGTALK_THINKING_REACTION_NAME,
+        'remove',
+      );
+      if (!attached || !cleaned) {
+        await new Promise((resolve) => {
+          const retry = setTimeout(resolve, Math.min(1_000, this.#reactionTimeoutMs));
+          retry.unref?.();
+        });
+        cleaned = await this.#runReactionCall(
+          'recallReaction',
+          reaction.target,
+          DINGTALK_THINKING_REACTION_NAME,
+          'remove',
+        ) || cleaned;
+      }
+      if (!cleaned || !terminalName || this.#signal?.aborted) return;
+      await this.#runReactionCall('addReaction', reaction.target, terminalName, 'add');
+    }).catch(() => undefined);
   }
 
   #enqueueMessage(message, messageId, sender, key, {
     releaseMessageId = true,
     alreadyRecorded = false,
     batchSubmission = null,
+    statusReaction = null,
   } = {}) {
     let hasSafeReplyRoute = false;
     try {
@@ -596,6 +755,7 @@ export class DingtalkHarnessBridge {
         alreadyRecorded,
         preparedMessage,
         batchSubmission,
+        statusReaction,
       }))
       .finally(() => {
         if (releaseMessageId) this.#acceptedMessageIds.delete(messageId);
@@ -648,7 +808,7 @@ export class DingtalkHarnessBridge {
     this.#status.lastError = null;
   }
 
-  #finishBatchResult(messageId, sessionWebhook, result) {
+  #finishBatchResult(messageId, sessionWebhook, result, statusReaction) {
     let task;
     task = Promise.resolve().then(async () => {
       if (this.#state.hasSeen(messageId)) return;
@@ -658,10 +818,18 @@ export class DingtalkHarnessBridge {
       if (result.message) await this.#send(sessionWebhook, result.message);
       this.#status.lastError = null;
     }).catch(async (error) => {
-      if (this.#signal?.aborted) return;
-      this.#status.lastError = t('钉钉命令处理失败。');
-      this.#logger.error?.('[dsh-dingtalk] failed to process a batch input message', safeErrorDiagnostic(error));
-      await this.#send(sessionWebhook, t(CARD_ERROR_TEXT)).catch(() => undefined);
+      if (this.#signal?.aborted) {
+        this.#finishStatusReaction(statusReaction, 'clear');
+        return;
+      }
+      this.#finishStatusReaction(statusReaction, 'error');
+      this.#status.lastError = error?.message ?? String(error);
+      const failure = setLastMessageFailure(this.#status, error);
+      this.#logger.error?.(
+        `[dsh-dingtalk] failed to process a batch input message [${failure.referenceId}]`,
+        safeErrorDiagnostic(error),
+      );
+      await this.#send(sessionWebhook, messageFailureText(failure)).catch(() => undefined);
     }).finally(() => {
       this.#acceptedMessageIds.delete(messageId);
       this.#commandTasks.delete(task);
@@ -674,6 +842,7 @@ export class DingtalkHarnessBridge {
     alreadyRecorded = false,
     preparedMessage,
     batchSubmission = null,
+    statusReaction = null,
   } = {}) {
     this.#signal?.throwIfAborted();
     if (!alreadyRecorded) {
@@ -819,7 +988,7 @@ export class DingtalkHarnessBridge {
           });
         }
       } catch (error) {
-        textDeliveryError = error;
+        textDeliveryError = channelDeliveryFailure(error);
       }
       const delivery = await this.#deliverArtifacts(
         fileTarget(message, sender, this.#clientId),
@@ -829,9 +998,15 @@ export class DingtalkHarnessBridge {
         textReceipt,
       );
       if (textDeliveryError && !delivery.userVisible) throw textDeliveryError;
+      if (textDeliveryError && delivery.artifactSendErrors === 0) {
+        setLastMessageFailure(this.#status, textDeliveryError);
+      }
       increment(this.#status, 'messagesReplied');
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
+      if (!textDeliveryError && delivery.artifactSendErrors === 0) {
+        clearLastMessageFailure(this.#status);
+      }
       return delivery.receipt;
     } catch (error) {
       let batchFailureMessage = null;
@@ -844,19 +1019,28 @@ export class DingtalkHarnessBridge {
         batchSettled = true;
       }
       if (error?.code === 'turn-stopped') {
+        this.#finishStatusReaction(statusReaction, 'clear');
         if (cardStarted) await cardStream.finish(t('已停止。')).catch(() => undefined);
         return;
       }
-      if (this.#signal?.aborted) return;
-      this.#status.lastError = t('钉钉消息处理失败。');
+      if (this.#signal?.aborted) {
+        this.#finishStatusReaction(statusReaction, 'clear');
+        return;
+      }
+      this.#finishStatusReaction(statusReaction, 'error');
+      this.#status.lastError = error?.message ?? String(error);
+      const userMessage = inboundFileUserMessage(error)
+        ?? dingtalkImageErrorUserMessage(error);
+      const failure = setLastMessageFailure(this.#status, error, {
+        userMessage,
+        reason: imagePromptDiagnostic(error)?.reason,
+      });
       this.#logger.error?.(
-        '[dsh-dingtalk] failed to process an inbound message',
+        `[dsh-dingtalk] failed to process an inbound message [${failure.referenceId}]`,
         safeErrorDiagnostic(error),
       );
       try {
-        const errorText = inboundFileUserMessage(error)
-          ?? dingtalkImageErrorUserMessage(error)
-          ?? t(CARD_ERROR_TEXT);
+        const errorText = messageFailureText(failure);
         const visibleError = batchFailureMessage
           ? `${errorText}\n\n${batchFailureMessage}`
           : errorText;
@@ -871,7 +1055,14 @@ export class DingtalkHarnessBridge {
     }
   }
 
-  async #processInteractionReply(message, messageId, sender, key, expected) {
+  async #processInteractionReply(
+    message,
+    messageId,
+    sender,
+    key,
+    expected,
+    statusReaction,
+  ) {
     this.#signal?.throwIfAborted();
     const current = this.#pendingInteractions.get(key);
     const claimed = expected.claimedReplyMessageId === messageId;
@@ -879,7 +1070,10 @@ export class DingtalkHarnessBridge {
       if (claimed && (!current || current !== expected)) {
         return this.#discardResolvedInteractionReply(message, messageId);
       }
-      return this.#enqueueMessage(message, messageId, sender, key, { releaseMessageId: false });
+      return this.#enqueueMessage(message, messageId, sender, key, {
+        releaseMessageId: false,
+        statusReaction,
+      });
     }
     if (this.#state.hasSeen(messageId)) return;
     await this.#state.markSeen(messageId);
@@ -924,6 +1118,7 @@ export class DingtalkHarnessBridge {
       return this.#enqueueMessage(message, messageId, sender, key, {
         releaseMessageId: false,
         alreadyRecorded: true,
+        statusReaction,
       });
     }
     pending.sessionWebhook = sessionWebhook;
@@ -931,6 +1126,7 @@ export class DingtalkHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch {
+        this.#finishStatusReaction(statusReaction, 'error');
         this.#status.lastError = t('钉钉交互问题发送失败。');
         this.#logger.error?.('[dsh-dingtalk] failed to retry an interaction question');
         pending.interaction.reconnect?.();
@@ -950,6 +1146,7 @@ export class DingtalkHarnessBridge {
       try {
         await this.#presentInteraction(pending);
       } catch {
+        this.#finishStatusReaction(statusReaction, 'error');
         this.#status.lastError = t('钉钉交互问题发送失败。');
         this.#logger.error?.('[dsh-dingtalk] failed to send the next interaction question');
         pending.interaction.reconnect?.();
@@ -969,7 +1166,10 @@ export class DingtalkHarnessBridge {
       this.#clearPendingInteraction(key, pending.interactionId);
       this.#status.lastError = null;
     } catch (error) {
-      if (this.#signal?.aborted) return;
+      if (this.#signal?.aborted) {
+        this.#finishStatusReaction(statusReaction, 'clear');
+        return;
+      }
       if (this.#pendingInteractions.get(key) !== pending) return;
       if (error?.code === 'interaction-not-pending') {
         this.#clearPendingInteraction(key, pending.interactionId);
@@ -980,6 +1180,7 @@ export class DingtalkHarnessBridge {
         }
         return;
       }
+      this.#finishStatusReaction(statusReaction, 'error');
       pending.submitting = false;
       pending.answers.pop();
       pending.index -= 1;
@@ -1201,9 +1402,13 @@ export class DingtalkHarnessBridge {
       sendFile: typeof this.#api.sendFile === 'function'
         ? (file) => sendArtifact('sendFile', file)
         : undefined,
-      sendFailureNotice: (artifact, error) => this.#send(
+      onFailure: (artifact, error) => setLastMessageFailure(this.#status, error, {
+        userMessage: artifactFailureText(artifact?.fileName, error),
+        reason: error?.code,
+      }),
+      sendFailureNotice: (_artifact, _error, failure) => this.#send(
         sessionWebhook,
-        artifactFailureText(artifact?.fileName, error),
+        messageFailureText(failure),
       ),
       logger: this.#logger,
     });
@@ -1211,7 +1416,11 @@ export class DingtalkHarnessBridge {
       + delivery.artifactsSent;
     this.#status.artifactSendErrors = (this.#status.artifactSendErrors ?? 0)
       + delivery.artifactSendErrors;
-    return { receipt: delivery.receipt, userVisible: delivery.userVisible };
+    return {
+      receipt: delivery.receipt,
+      userVisible: delivery.userVisible,
+      artifactSendErrors: delivery.artifactSendErrors,
+    };
   }
 }
 

package/src/channels/dingtalk/dingtalk-card-stream.mjs

@@ -1,7 +1,7 @@
 import { t } from '../shared/i18n.mjs';
 
 const DEFAULT_UPDATE_INTERVAL_MS = 500;
-const FAILURE_TEXT = '消息处理失败，请稍后重试。';
+const CLOSED_TEXT = '卡片已结束，请查看后续消息。';
 
 function requiredText(value, name) {
   if (typeof value !== 'string') throw new TypeError(`${name} must be a string`);
@@ -102,7 +102,7 @@ export function createDingTalkCardStream({
     if (!cleanupPromise) {
       cleanupPromise = api.failAiCard({
         ...cardRequest,
-        text: t(FAILURE_TEXT),
+        text: t(CLOSED_TEXT),
         signal: AbortSignal.timeout(5_000),
       }).then(
         () => true,

package/src/channels/dingtalk/dingtalk-controller.mjs

@@ -11,6 +11,7 @@ import {
   connectionTestTargetUnavailable,
 } from '../shared/connection-test.mjs';
 import { t } from '../shared/i18n.mjs';
+import { publicMessageFailure } from '../shared/message-failure.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['starting', 'pending', 'connecting']);
 const TERMINAL_ATTEMPT_STATES = new Set(['connected', 'expired', 'failed', 'cancelled']);
@@ -516,6 +517,7 @@ export class DingtalkController {
           messagesReceived: Number(currentStatus.messagesReceived) || 0,
           messagesReplied: Number(currentStatus.messagesReplied) || 0,
         },
+        lastMessageError: publicMessageFailure(currentStatus.lastMessageError),
         senders: {
           pending,
           approved: config.approvedSenders.map(publicApprovedSender),

package/src/channels/discord/discord-api.mjs

@@ -88,6 +88,12 @@ function snowflake(value, name) {
   return id;
 }
 
+function reactionEmoji(value) {
+  const emoji = cleanString(value);
+  if (!emoji) throw new TypeError('A Discord reaction emoji is required');
+  return emoji;
+}
+
 export function validDiscordToken(value) {
   return typeof value === 'string'
     && /^[A-Za-z0-9_-]{20,}\.[A-Za-z0-9_-]{4,}\.[A-Za-z0-9_-]{20,}$/.test(value.trim());
@@ -229,6 +235,35 @@ export class DiscordApi {
     });
   }
 
+  async addOwnReaction({ channelId, messageId, emoji, signal } = {}) {
+    const normalizedEmoji = reactionEmoji(emoji);
+    await this.#request(
+      `channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`
+        + `/reactions/${encodeURIComponent(normalizedEmoji)}/@me`,
+      {
+        method: 'PUT',
+        signal,
+        expectBody: false,
+        retry: false,
+      },
+    );
+    return normalizedEmoji;
+  }
+
+  removeOwnReaction({ channelId, messageId, emoji, signal } = {}) {
+    const normalizedEmoji = reactionEmoji(emoji);
+    return this.#request(
+      `channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`
+        + `/reactions/${encodeURIComponent(normalizedEmoji)}/@me`,
+      {
+        method: 'DELETE',
+        signal,
+        expectBody: false,
+        retry: false,
+      },
+    );
+  }
+
   async #request(path, {
     method,
     body,

package/src/channels/discord/discord-bridge.mjs

@@ -4,6 +4,7 @@ export const DISCORD_DESCRIPTOR = Object.freeze({
   key: 'discord',
   label: 'Discord',
   connectionLabel: ' Gateway 长连接',
+  reactions: Object.freeze({ processing: '👀', success: '✅', error: '❌' }),
 });
 
 export class DiscordHarnessBridge extends TextHarnessBridge {

package/src/channels/discord/discord-runtime.mjs

@@ -231,6 +231,10 @@ export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } =
       channelId: String(message.channel_id),
       replyToMessageId: String(message.id),
     },
+    reactionTarget: {
+      channelId: String(message.channel_id),
+      messageId: String(message.id),
+    },
     connectionTestTarget: { channelId: String(message.channel_id) },
   };
 }
@@ -350,6 +354,24 @@ export class DiscordBotClient {
     });
   }
 
+  addReaction(target, emoji, { signal } = {}) {
+    return this.#api.addOwnReaction({
+      channelId: target.channelId,
+      messageId: target.messageId,
+      emoji,
+      signal: this.#operationSignal(signal),
+    });
+  }
+
+  removeReaction(target, reactionKey, { signal } = {}) {
+    return this.#api.removeOwnReaction({
+      channelId: target.channelId,
+      messageId: target.messageId,
+      emoji: reactionKey,
+      signal: this.#operationSignal(signal),
+    });
+  }
+
   async openStream(target) {
     const notice = !this.#deliveredNotices.has(target) && target?.notice
       ? String(target.notice) : null;
@@ -381,6 +403,10 @@ export class DiscordBotClient {
     });
     return stream.start();
   }
+
+  #operationSignal(signal) {
+    return signal ?? this.#signal;
+  }
 }
 
 export function createDiscordRuntimeStatus() {