@xmanrui/dsh-im 0.9.0 → 0.11.0

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

@@ -5,6 +5,7 @@ import { createSlackBridgeStatus, SlackHarnessBridge } from './slack-bridge.mjs'
 const RECONNECT_DELAYS_MS = Object.freeze([1_000, 3_000, 5_000, 10_000, 30_000]);
 const SLACK_MESSAGE_LIMIT = 38_000;
 const SLACK_STREAM_CHUNK_LIMIT = 11_000;
+const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
 
 function addSocketListener(socket, event, listener) {
   if (typeof socket.addEventListener === 'function') socket.addEventListener(event, listener);
@@ -42,13 +43,28 @@ function stripBotMention(value, botUserId) {
     .trim();
 }
 
-export function normalizeSlackEvent(payload, botUserId) {
+function slackImageSource(file, loadFile) {
+  const mediaType = typeof file?.mimetype === 'string' ? file.mimetype.toLowerCase() : '';
+  const url = typeof file?.url_private_download === 'string' && file.url_private_download
+    ? file.url_private_download : file?.url_private;
+  if (!IMAGE_MEDIA_TYPES.has(mediaType) || typeof url !== 'string' || !url) return null;
+  return {
+    name: typeof file.name === 'string' ? file.name : undefined,
+    mediaType,
+    size: Number.isSafeInteger(file.size) && file.size >= 0 ? file.size : undefined,
+    load: (options) => loadFile(url, options),
+  };
+}
+
+export function normalizeSlackEvent(payload, botUserId, { loadFile = async () => {
+  throw new Error('Slack file downloader is unavailable');
+} } = {}) {
   const event = payload?.event;
   if (!event || !payload?.event_id || !event.channel || !event.user || !event.ts) return null;
   const direct = event.type === 'message' && event.channel_type === 'im';
   const mentioned = event.type === 'app_mention';
   if (!direct && !mentioned) return null;
-  if (event.subtype || event.bot_id || event.app_id) return null;
+  if ((event.subtype && event.subtype !== 'file_share') || event.bot_id || event.app_id) return null;
   const threadTs = String(event.thread_ts ?? event.ts);
   return {
     messageId: String(payload.event_id),
@@ -57,6 +73,9 @@ export function normalizeSlackEvent(payload, botUserId) {
     kind: direct ? 'direct' : 'group',
     conversationId: direct ? String(event.channel) : `${event.channel}:${threadTs}`,
     content: stripBotMention(event.text ?? '', botUserId),
+    images: Array.isArray(event.files)
+      ? event.files.map((file) => slackImageSource(file, loadFile)).filter(Boolean)
+      : [],
     addressed: direct || mentioned,
     replyTarget: {
       channelId: String(event.channel),
@@ -64,6 +83,7 @@ export function normalizeSlackEvent(payload, botUserId) {
       recipientUserId: String(event.user),
       recipientTeamId: String(event.user_team ?? payload.team_id ?? ''),
     },
+    connectionTestTarget: { channelId: String(event.channel) },
   };
 }
 
@@ -274,6 +294,15 @@ export class SlackRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Slack bot is not connected');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    return this.#bridge.sendConnectionTest(text);
+  }
+
   async start() {
     if (this.#status.ready && this.#socket) return this.status;
     if (this.#starting) return this.#starting;
@@ -389,7 +418,9 @@ export class SlackRuntime {
         if (packet.type !== 'events_api' || packet.payload?.type !== 'event_callback') return;
         if (this.#appId && packet.payload.api_app_id
           && packet.payload.api_app_id !== this.#appId) return;
-        const message = normalizeSlackEvent(packet.payload, this.#config.platformId.split(':')[1]);
+        const message = normalizeSlackEvent(packet.payload, this.#config.platformId.split(':')[1], {
+          loadFile: (url, options) => this.#api.downloadFile({ url, ...options }),
+        });
         const bridge = this.#bridge;
         if (message && bridge) {
           void bridge.accept(message).catch((error) => {

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

@@ -1,4 +1,7 @@
+import { fetchImageBuffer } from '../shared/image-prompt.mjs';
+
 const DEFAULT_BASE_URL = 'https://api.telegram.org/';
+const TELEGRAM_FILE_HOSTS = Object.freeze(['api.telegram.org']);
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -47,6 +50,40 @@ export class TelegramApi {
     });
   }
 
+  async getFile({ fileId, signal } = {}) {
+    const id = cleanString(fileId);
+    if (!id || !/^[A-Za-z0-9_-]{1,512}$/.test(id)) {
+      throw new TypeError('Telegram file id is invalid');
+    }
+    return this.#call('getFile', { file_id: id }, { signal });
+  }
+
+  async downloadFile({ fileId, signal, maxBytes } = {}) {
+    const file = await this.getFile({ fileId, signal });
+    const filePath = cleanString(file?.file_path);
+    if (!filePath || filePath.startsWith('/') || filePath.includes('\\')
+      || filePath.includes('?') || filePath.includes('#')) {
+      throw new Error('Telegram returned an invalid file path');
+    }
+    let decodedSegments;
+    try {
+      decodedSegments = filePath.split('/').map((segment) => decodeURIComponent(segment));
+    } catch {
+      throw new Error('Telegram returned an invalid file path');
+    }
+    if (decodedSegments.some((segment) => !segment || segment === '.' || segment === '..')) {
+      throw new Error('Telegram returned an invalid file path');
+    }
+    const url = new URL(this.#baseUrl);
+    url.pathname = `/file/bot${this.#token}/${filePath}`;
+    return fetchImageBuffer(url, {
+      fetchImpl: this.#fetch,
+      signal,
+      maxBytes,
+      allowedHosts: TELEGRAM_FILE_HOSTS,
+    });
+  }
+
   async sendMessage({ chatId, text, replyToMessageId, messageThreadId, signal }) {
     return this.#call('sendMessage', {
       chat_id: chatId,

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

@@ -7,14 +7,17 @@ function escaped(value) {
 }
 
 function mentionedUsername(message, username) {
-  if (!username || typeof message?.text !== 'string' || !Array.isArray(message.entities)) return false;
-  return message.entities.some((entity) => {
-    if (entity?.type !== 'mention' || !Number.isInteger(entity.offset) || !Number.isInteger(entity.length)) {
-      return false;
-    }
-    return message.text.slice(entity.offset, entity.offset + entity.length).toLowerCase()
-      === `@${username.toLowerCase()}`;
-  });
+  if (!username) return false;
+  return [
+    [message?.text, message?.entities],
+    [message?.caption, message?.caption_entities],
+  ].some(([text, entities]) => typeof text === 'string' && Array.isArray(entities)
+    && entities.some((entity) => {
+      if (entity?.type !== 'mention' || !Number.isInteger(entity.offset)
+        || !Number.isInteger(entity.length)) return false;
+      return text.slice(entity.offset, entity.offset + entity.length).toLowerCase()
+        === `@${username.toLowerCase()}`;
+    }));
 }
 
 function withoutBotMention(text, username) {
@@ -22,7 +25,63 @@ function withoutBotMention(text, username) {
   return text.replace(new RegExp(`@${escaped(username)}\\b`, 'ig'), '').trim();
 }
 
-export function normalizeTelegramUpdate(update, { botId, username }) {
+const IMAGE_MEDIA_TYPES = new Set(['image/jpeg', 'image/png', 'image/webp', 'image/gif']);
+const IMAGE_FILE_TYPES = new Map([
+  ['.jpg', 'image/jpeg'],
+  ['.jpeg', 'image/jpeg'],
+  ['.png', 'image/png'],
+  ['.webp', 'image/webp'],
+  ['.gif', 'image/gif'],
+]);
+
+function imageTypeForDocument(document) {
+  const declaredType = document?.mime_type ?? document?.mimetype;
+  const type = typeof declaredType === 'string' ? declaredType.toLowerCase() : '';
+  if (IMAGE_MEDIA_TYPES.has(type)) return type;
+  const filename = typeof document?.file_name === 'string' ? document.file_name.toLowerCase() : '';
+  for (const [extension, mediaType] of IMAGE_FILE_TYPES) {
+    if (filename.endsWith(extension)) return mediaType;
+  }
+  return null;
+}
+
+function fileSize(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+
+function photoScore(photo) {
+  return fileSize(photo?.file_size) ?? ((Number(photo?.width) || 0) * (Number(photo?.height) || 0));
+}
+
+function telegramImageSource(message, loadFile) {
+  let file;
+  let mediaType;
+  let name;
+  if (Array.isArray(message?.photo) && message.photo.length > 0) {
+    file = message.photo.reduce((largest, candidate) => (
+      photoScore(candidate) > photoScore(largest) ? candidate : largest
+    ));
+    mediaType = 'image/jpeg';
+    name = `${file.file_unique_id ?? file.file_id ?? 'telegram-photo'}.jpg`;
+  } else if (message?.document) {
+    const type = imageTypeForDocument(message.document);
+    if (!type) return null;
+    file = message.document;
+    mediaType = type;
+    name = typeof file.file_name === 'string' ? file.file_name : undefined;
+  }
+  if (!file || typeof file.file_id !== 'string') return null;
+  return {
+    name,
+    mediaType,
+    size: fileSize(file.file_size),
+    load: (options) => loadFile(file.file_id, options),
+  };
+}
+
+export function normalizeTelegramUpdate(update, { botId, username, loadFile = async () => {
+  throw new Error('Telegram file downloader is unavailable');
+} }) {
   const message = update?.message;
   const chatId = message?.chat?.id;
   const senderId = message?.from?.id;
@@ -36,6 +95,7 @@ export function normalizeTelegramUpdate(update, { botId, username }) {
     || mentionedUsername(message, username);
   const messageThreadId = Number.isSafeInteger(message.message_thread_id)
     ? message.message_thread_id : undefined;
+  const image = telegramImageSource(message, loadFile);
   return {
     messageId: String(update.update_id),
     senderId: String(senderId),
@@ -44,12 +104,14 @@ export function normalizeTelegramUpdate(update, { botId, username }) {
     conversationId: messageThreadId === undefined
       ? String(chatId) : `${chatId}:${messageThreadId}`,
     content: withoutBotMention(message.text ?? message.caption ?? '', username),
+    images: image ? [image] : [],
     addressed,
     replyTarget: {
       chatId,
       replyToMessageId: messageId,
       messageThreadId,
     },
+    connectionTestTarget: { chatId, messageThreadId },
   };
 }
 
@@ -168,6 +230,15 @@ export class TelegramRuntime {
     return structuredClone(this.#status);
   }
 
+  async sendConnectionTest(text) {
+    if (!this.#status.ready || !this.#bridge) {
+      const error = new Error('Telegram bot is not connected');
+      error.code = 'test-target-unavailable';
+      throw error;
+    }
+    return this.#bridge.sendConnectionTest(text);
+  }
+
   async start() {
     if (this.#status.ready && this.#pollTask) return this.status;
     if (this.#starting) return this.#starting;
@@ -250,6 +321,7 @@ export class TelegramRuntime {
         const message = normalizeTelegramUpdate(update, {
           botId: this.#config.platformId,
           username: this.#config.username,
+          loadFile: (fileId, options) => this.#api.downloadFile({ fileId, ...options }),
         });
         if (message) {
           void this.#bridge.accept(message).catch((error) => {

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

@@ -8,11 +8,18 @@ import { HarnessApprovalQueue } from '../shared/harness-approval.mjs';
 import { runCompactCommand } from '../shared/compact-command.mjs';
 import { runWorkspaceCommand } from '../shared/workspace-command.mjs';
 import { askInWorkspaceSession } from '../shared/workspace-session.mjs';
+import {
+  hasInboundImages,
+  ImagePromptError,
+  imagePromptUserMessage,
+  promptContentForMessage,
+} from '../shared/image-prompt.mjs';
+import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
 
 const HELP_TEXT = [
   '企业微信机器人已连接 DeepSeek Harness。',
   '',
-  '直接发送文字即可继续当前会话。',
+  '直接发送文字或图片即可继续当前会话。',
   '/new  开启一个全新会话',
   '/compact  压缩当前会话的较早上下文',
   '/workspace 工作区绝对路径  切换工作区',
@@ -23,6 +30,8 @@ const HELP_TEXT = [
   '/help  显示本帮助',
 ].join('\n');
 const MAX_REPLY_BYTES = 18_000;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const MAX_PREFETCHED_IMAGES = 4;
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
 
 function nonEmptyString(value) {
@@ -59,6 +68,102 @@ function messageText(frame) {
     : text;
 }
 
+function imageContents(frame) {
+  const body = bodyOf(frame);
+  if (body.msgtype === 'image') return [body.image];
+  if (body.msgtype !== 'mixed' || !Array.isArray(body.mixed?.msg_item)) return [];
+  return body.mixed.msg_item
+    .filter((item) => item?.msgtype === 'image')
+    .map((item) => item.image);
+}
+
+function imageSource(client, image) {
+  const url = nonEmptyString(image?.url);
+  if (!url) return null;
+  const aeskey = nonEmptyString(image?.aeskey) ?? undefined;
+  return {
+    async load({ signal, maxBytes }) {
+      signal?.throwIfAborted();
+      if (typeof client?.downloadFile !== 'function') {
+        throw new Error('Enterprise WeChat image download is unavailable');
+      }
+      const result = await client.downloadFile(url, aeskey);
+      signal?.throwIfAborted();
+      const raw = result?.buffer;
+      if (!Buffer.isBuffer(raw) && !(raw instanceof Uint8Array)) {
+        throw new Error('Enterprise WeChat image download returned no data');
+      }
+      const data = Buffer.from(raw);
+      if (Number.isFinite(maxBytes) && data.length > maxBytes) {
+        throw new ImagePromptError(
+          'image-too-large',
+          `Enterprise WeChat image exceeds ${maxBytes} bytes`,
+          '图片超过 5 MB，请压缩后重试。',
+        );
+      }
+      return { data, name: result?.filename };
+    },
+  };
+}
+
+export function wecomInboundMessage(frame, client) {
+  return {
+    content: messageText(frame),
+    images: imageContents(frame).map((image) => imageSource(client, image)).filter(Boolean),
+  };
+}
+
+function prefetchInboundImages(message, signal) {
+  if (!hasInboundImages(message)) return message;
+  return {
+    ...message,
+    images: message.images.map((source) => {
+      const download = source.load({ signal, maxBytes: MAX_IMAGE_BYTES });
+      // The conversation queue may not consume this promise immediately. Keep
+      // an attached rejection handler while preserving the original outcome.
+      download.catch(() => undefined);
+      return {
+        ...source,
+        async load({ signal: loadSignal, maxBytes = MAX_IMAGE_BYTES } = {}) {
+          loadSignal?.throwIfAborted();
+          const result = await download;
+          loadSignal?.throwIfAborted();
+          const raw = result?.data ?? result?.buffer ?? result;
+          const size = Buffer.isBuffer(raw) || raw instanceof Uint8Array ? raw.length : 0;
+          if (size > maxBytes) {
+            throw new ImagePromptError(
+              'image-too-large',
+              `Enterprise WeChat image exceeds ${maxBytes} bytes`,
+              '图片超过 5 MB，请压缩后重试。',
+            );
+          }
+          return result;
+        },
+      };
+    }),
+  };
+}
+
+function imageQueueFullMessage(message) {
+  return {
+    ...message,
+    images: message.images.map((source) => ({
+      ...source,
+      async load() {
+        throw new ImagePromptError(
+          'image-queue-full',
+          `Enterprise WeChat already has ${MAX_PREFETCHED_IMAGES} prefetched images`,
+          '当前待处理图片较多，请稍后重新发送。',
+        );
+      },
+    })),
+  };
+}
+
+function interactionReplyText(frame) {
+  return bodyOf(frame).msgtype === 'text' ? messageText(frame) : '';
+}
+
 function splitUtf8(text, maxBytes = MAX_REPLY_BYTES) {
   const source = String(text ?? '').trim();
   if (!source) return [];
@@ -89,7 +194,7 @@ function progressText(update) {
 function canClaimInteractionReply(frame, pending) {
   return pending.questions[pending.index]
     && nonEmptyString(bodyOf(frame).from?.userid) === pending.actor
-    && nonEmptyString(messageText(frame));
+    && nonEmptyString(interactionReplyText(frame));
 }
 
 export function createWecomBridgeStatus() {
@@ -119,6 +224,7 @@ export class WecomHarnessBridge {
   #acceptedMessageIds = new Set();
   #approvalTasks = new Set();
   #approvals;
+  #prefetchedImageCount = 0;
 
   constructor({
     client,
@@ -164,12 +270,15 @@ export class WecomHarnessBridge {
 
     const key = conversationKey(frame);
     this.#acceptedMessageIds.add(messageId);
+    if (body.chattype === 'single') {
+      rememberConnectionTestTarget(this.#state, { chatId });
+    }
     const pending = this.#pendingInteractions.get(key);
     const approval = this.#approvals.claimReply({
       key,
       actor: senderId,
       messageId,
-      text: messageText(frame),
+      text: interactionReplyText(frame),
       addressed: true,
       hasPendingQuestion: Boolean(pending),
       questionCompletion: pending?.submitting || pending?.claimedReplyMessageId
@@ -232,11 +341,28 @@ export class WecomHarnessBridge {
     releaseMessageId = true,
     alreadyRecorded = false,
   } = {}) {
+    // WeCom image URLs expire after five minutes, while a conversation turn
+    // may legally stay queued longer. Start the authenticated SDK download as
+    // soon as the validated callback is accepted, then consume it in order.
+    const inboundMessage = wecomInboundMessage(frame, this.#client);
+    const imageCount = inboundMessage.images.length;
+    let reservedImages = 0;
+    let preparedMessage = inboundMessage;
+    if (imageCount > 0) {
+      if (this.#prefetchedImageCount + imageCount <= MAX_PREFETCHED_IMAGES) {
+        reservedImages = imageCount;
+        this.#prefetchedImageCount += reservedImages;
+        preparedMessage = prefetchInboundImages(inboundMessage, this.#signal);
+      } else {
+        preparedMessage = imageQueueFullMessage(inboundMessage);
+      }
+    }
     const previous = this.#queues.get(key) ?? Promise.resolve();
     const current = previous
       .catch(() => undefined)
-      .then(() => this.#process(frame, { alreadyRecorded }))
+      .then(() => this.#process(frame, { alreadyRecorded, preparedMessage }))
       .finally(() => {
+        this.#prefetchedImageCount -= reservedImages;
         if (releaseMessageId) this.#acceptedMessageIds.delete(messageId);
         if (this.#queues.get(key) === current) this.#queues.delete(key);
       });
@@ -275,7 +401,7 @@ export class WecomHarnessBridge {
     }
   }
 
-  async #process(frame, { alreadyRecorded = false } = {}) {
+  async #process(frame, { alreadyRecorded = false, preparedMessage } = {}) {
     if (this.#signal?.aborted) return;
     const body = bodyOf(frame);
     const messageId = typeof body.msgid === 'string' ? body.msgid : '';
@@ -287,35 +413,39 @@ export class WecomHarnessBridge {
       this.#status.messagesReceived += 1;
       this.#status.lastMessageAt = new Date().toISOString();
     }
-    const text = messageText(frame);
+    const message = preparedMessage ?? wecomInboundMessage(frame, this.#client);
+    const text = message.content;
+    const hasImages = hasInboundImages(message);
     const key = conversationKey(frame);
     let streamId = null;
     let streamStarted = false;
     try {
-      if (!text) {
-        await this.#sendImmediate(frame, chatId, '目前支持文字、语音转写和图文混排中的文字消息。');
+      if (!text && !hasImages) {
+        await this.#sendImmediate(frame, chatId, '目前支持文字、图片和语音转写消息。');
         await this.#state.markSeen(messageId);
         return;
       }
       const command = text.toLowerCase();
-      if (command === '/help') {
+      if (!hasImages && command === '/help') {
         await this.#sendImmediate(frame, chatId, HELP_TEXT);
         await this.#state.markSeen(messageId);
         return;
       }
-      if (command === '/status') {
+      if (!hasImages && command === '/status') {
         await this.#harness.ensureRunning({ signal: this.#signal });
         await this.#sendImmediate(frame, chatId, '企业微信机器人与 DeepSeek Harness 连接正常。');
         await this.#state.markSeen(messageId);
         return;
       }
-      if (command === '/new') {
+      if (!hasImages && command === '/new') {
         await this.#state.clearSession(key);
         await this.#sendImmediate(frame, chatId, '已开启新会话。请发送你的问题。');
         await this.#state.markSeen(messageId);
         return;
       }
-      const workspaceCommand = await runWorkspaceCommand(text, this.#harness, key);
+      const workspaceCommand = hasImages
+        ? null
+        : await runWorkspaceCommand(text, this.#harness, key);
       if (workspaceCommand) {
         for (const reply of workspaceCommand.messages ?? [workspaceCommand.message]) {
           await this.#sendImmediate(frame, chatId, reply);
@@ -323,13 +453,15 @@ export class WecomHarnessBridge {
         await this.#state.markSeen(messageId);
         return;
       }
-      const compactCommand = await runCompactCommand(
-        text,
-        this.#harness,
-        this.#state,
-        key,
-        { signal: this.#signal },
-      );
+      const compactCommand = hasImages
+        ? null
+        : await runCompactCommand(
+            text,
+            this.#harness,
+            this.#state,
+            key,
+            { signal: this.#signal },
+          );
       if (compactCommand) {
         await this.#sendImmediate(frame, chatId, compactCommand.message);
         await this.#state.markSeen(messageId);
@@ -344,11 +476,15 @@ export class WecomHarnessBridge {
         this.#logger.warn?.('[dsh-im:wecom] unable to start a stream; using an active reply:', error);
       }
 
+      const content = hasImages
+        ? await promptContentForMessage(message, { signal: this.#signal })
+        : undefined;
       const { answer } = await askInWorkspaceSession({
         harness: this.#harness,
         state: this.#state,
         key,
         text,
+        content,
         createOptions: { signal: this.#signal },
         existsOptions: { signal: this.#signal },
         askOptions: {
@@ -392,11 +528,12 @@ export class WecomHarnessBridge {
       if (this.#signal?.aborted) return;
       this.#status.lastError = error?.message ?? String(error);
       this.#logger.error?.('[dsh-im:wecom] failed to process an inbound message');
+      const errorText = imagePromptUserMessage(error) ?? '消息处理失败，请稍后重试。';
       try {
         if (streamStarted && streamId) {
-          await this.#client.replyStream(frame, streamId, '消息处理失败，请稍后重试。', true);
+          await this.#client.replyStream(frame, streamId, errorText, true);
         } else {
-          await this.#sendImmediate(frame, chatId, '消息处理失败，请稍后重试。');
+          await this.#sendImmediate(frame, chatId, errorText);
         }
         await this.#state.markSeen(messageId);
       } catch {
@@ -425,9 +562,9 @@ export class WecomHarnessBridge {
     this.#status.messagesReceived += 1;
     this.#status.lastMessageAt = new Date().toISOString();
 
-    const text = nonEmptyString(messageText(frame));
+    const text = nonEmptyString(interactionReplyText(frame));
     if (!text) {
-      await this.#sendImmediate(frame, chatId, '请用文字或语音回答当前问题。')
+      await this.#sendImmediate(frame, chatId, '请用文字回答当前问题。')
         .catch(() => undefined);
       return;
     }

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

@@ -1,6 +1,10 @@
 import { randomUUID } from 'node:crypto';
 
 import { deriveWecomBotIdentity, maskWecomBotId } from './config-store.mjs';
+import {
+  connectionTestMessage,
+  connectionTestTargetUnavailable,
+} from '../shared/connection-test.mjs';
 
 const ACTIVE_ATTEMPT_STATES = new Set(['pending', 'connecting']);
 const TERMINAL_ATTEMPT_STATES = new Set(['connected', 'failed', 'cancelled', 'expired']);
@@ -237,6 +241,20 @@ export class WecomController {
     return this.status();
   }
 
+  async sendConnectionTest(botId) {
+    const config = this.#configStore.get(botId);
+    if (!config) throw new Error('Unknown Enterprise WeChat bot');
+    return this.#withBotTransition(botId, async () => {
+      const runtime = this.#runtimes.get(botId);
+      if (!runtime?.status?.ready || typeof runtime.sendConnectionTest !== 'function') {
+        throw connectionTestTargetUnavailable('企业微信机器人');
+      }
+      return runtime.sendConnectionTest(connectionTestMessage(
+        `企业微信机器人（${maskWecomBotId(config.remoteBotId)}）`,
+      ));
+    });
+  }
+
   async deleteBot(botId) {
     const config = this.#configStore.get(botId);
     if (!config) throw new Error('Unknown Enterprise WeChat bot');

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

@@ -1,6 +1,7 @@
 import { WSAuthFailureError, WSClient, WSReconnectExhaustedError } from '@wecom/aibot-node-sdk';
 
 import { createWecomBridgeStatus, WecomHarnessBridge } from './wecom-bridge.mjs';
+import { sendRememberedConnectionTest } from '../shared/connection-test.mjs';
 
 function timeoutError() {
   const error = new Error('Enterprise WeChat WebSocket authentication timed out');
@@ -197,6 +198,23 @@ export class WecomRuntime {
     return this.status;
   }
 
+  async sendConnectionTest(text) {
+    return sendRememberedConnectionTest({
+      state: this.#state,
+      text,
+      channelLabel: '企业微信机器人',
+      send: async ({ chatId }, content) => {
+        if (!this.#status.ready || !this.#client) {
+          throw new Error('Enterprise WeChat runtime is not connected');
+        }
+        await this.#client.sendMessage(chatId, {
+          msgtype: 'markdown',
+          markdown: { content },
+        });
+      },
+    });
+  }
+
   async #stopActive() {
     const client = this.#client;
     const bridge = this.#bridge;