@xmanrui/dsh-im 1.0.2 → 1.2.0

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

@@ -120,6 +120,7 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
   let inFlight = null;
   let broken = false;
   let closed = false;
+  const providerMessageIds = [ts];
 
   const appendLatest = async (text) => {
     const next = splitMessageText(text, SLACK_MESSAGE_LIMIT)[0] ?? '';
@@ -150,6 +151,10 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
   };
 
   return {
+    messageId: ts,
+    get providerMessageIds() {
+      return [...providerMessageIds];
+    },
     update(text) {
       if (closed || broken || typeof text !== 'string' || !text.trim() || isToolProgress(text)) return;
       pending = text;
@@ -173,12 +178,13 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
         await api.updateMessage({ channelId: target.channelId, ts, text: first, signal });
       }
       for (const chunk of chunks.slice(1)) {
-        await api.postMessage({
+        const result = await api.postMessage({
           channelId: target.channelId,
           threadTs: target.threadTs,
           text: chunk,
           signal,
         });
+        if (typeof result?.ts === 'string' && result.ts) providerMessageIds.push(result.ts);
       }
     },
     cancel() {
@@ -191,7 +197,7 @@ async function createSlackMessageStream({ api, target, signal, logger }) {
   };
 }
 
-class SlackBotClient {
+export class SlackBotClient {
   #api;
   #signal;
   #logger;
@@ -204,16 +210,17 @@ class SlackBotClient {
 
   async sendText(target, text) {
     const chunks = splitMessageText(text, SLACK_MESSAGE_LIMIT);
-    let result = null;
+    const providerMessageIds = [];
     for (const chunk of chunks) {
-      result = await this.#api.postMessage({
+      const result = await this.#api.postMessage({
         channelId: target.channelId,
         threadTs: target.threadTs,
         text: chunk,
         signal: this.#signal,
       });
+      if (typeof result?.ts === 'string' && result.ts) providerMessageIds.push(result.ts);
     }
-    return result;
+    return { providerMessageIds };
   }
 
   openStream(target) {
@@ -224,6 +231,15 @@ class SlackBotClient {
       logger: this.#logger,
     });
   }
+
+  sendFile(target, file) {
+    return this.#api.uploadFile({
+      channelId: target.channelId,
+      threadTs: target.threadTs,
+      file,
+      signal: this.#signal,
+    });
+  }
 }
 
 export function createSlackRuntimeStatus() {

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

@@ -2,6 +2,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']);
+const DEFAULT_FILE_UPLOAD_TIMEOUT_MS = 120_000;
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -12,6 +13,58 @@ function requestSignal(signal, timeoutMs) {
   return signal ? AbortSignal.any([signal, timeout]) : timeout;
 }
 
+function abortReason(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new DOMException('The operation was aborted', 'AbortError');
+}
+
+function positiveTimeout(value, name) {
+  if (!Number.isInteger(value) || value < 1) throw new TypeError(`${name} must be a positive integer`);
+  return value;
+}
+
+function preserveProviderMetadata(target, source) {
+  if (source?.providerCode !== undefined) target.providerCode = source.providerCode;
+  if (source?.retry_after !== undefined) {
+    target.retry_after = source.retry_after;
+    target.retryAfter = source.retry_after;
+  }
+  if (Number.isInteger(source?.status)) target.status = source.status;
+  return target;
+}
+
+function telegramArtifactProviderError(cause) {
+  const providerCode = Number(cause?.providerCode);
+  const status = Number(cause?.status);
+  const message = cleanString(cause?.message) ?? '';
+  let code = 'artifact-provider-rejected';
+  let summary = 'Telegram rejected the document.';
+  if (providerCode === 401 || providerCode === 403 || status === 401 || status === 403) {
+    code = 'artifact-permission-required';
+    summary = 'Telegram denied permission to send the document.';
+  } else if (providerCode === 413 || status === 413
+    || /(?:file|request|entity).{0,20}(?:too (?:big|large)|size limit)|too (?:big|large)/i.test(message)) {
+    code = 'artifact-too-large';
+    summary = 'The document exceeds Telegram\'s size limit.';
+  } else if (providerCode === 429 || status === 429) {
+    code = 'artifact-rate-limited';
+    summary = 'Telegram rate-limited document delivery.';
+  } else if (providerCode >= 500 || status >= 500) {
+    code = 'artifact-delivery-uncertain';
+    summary = 'Telegram document delivery result is uncertain.';
+  }
+  const error = new Error(summary, { cause });
+  error.code = code;
+  return preserveProviderMetadata(error, cause);
+}
+
+function uncertainTelegramDelivery(cause) {
+  const error = new Error('Telegram document delivery result is uncertain', { cause });
+  error.code = 'artifact-delivery-uncertain';
+  return preserveProviderMetadata(error, cause);
+}
+
 export function validTelegramToken(value) {
   return typeof value === 'string' && /^\d{5,20}:[A-Za-z0-9_-]{20,}$/.test(value.trim());
 }
@@ -32,13 +85,20 @@ export class TelegramApi {
   #token;
   #fetch;
   #baseUrl;
+  #fileUploadTimeoutMs;
 
-  constructor({ token, fetchImpl = fetch, baseUrl = DEFAULT_BASE_URL }) {
+  constructor({
+    token,
+    fetchImpl = fetch,
+    baseUrl = DEFAULT_BASE_URL,
+    fileUploadTimeoutMs = DEFAULT_FILE_UPLOAD_TIMEOUT_MS,
+  }) {
     if (!validTelegramToken(token)) throw new TypeError('Telegram Bot Token is invalid');
     if (typeof fetchImpl !== 'function') throw new TypeError('TelegramApi requires fetch');
     this.#token = token.trim();
     this.#fetch = fetchImpl;
     this.#baseUrl = new URL(baseUrl);
+    this.#fileUploadTimeoutMs = positiveTimeout(fileUploadTimeoutMs, 'fileUploadTimeoutMs');
   }
 
   async getMe(options = {}) {
@@ -108,6 +168,43 @@ export class TelegramApi {
     }, { signal });
   }
 
+  async sendDocument({ chatId, file, replyToMessageId, messageThreadId, signal }) {
+    if (!file || typeof file !== 'object'
+      || typeof file.fileName !== 'string' || !file.fileName
+      || !Buffer.isBuffer(file.bytes)) {
+      throw new TypeError('A Telegram document is required');
+    }
+    const payload = new FormData();
+    payload.append('chat_id', String(chatId));
+    payload.append(
+      'document',
+      new Blob([file.bytes], { type: file.mediaType ?? 'application/octet-stream' }),
+      file.fileName,
+    );
+    if (replyToMessageId) {
+      payload.append('reply_parameters', JSON.stringify({
+        message_id: replyToMessageId,
+        allow_sending_without_reply: true,
+      }));
+    }
+    if (messageThreadId) payload.append('message_thread_id', String(messageThreadId));
+    if (signal?.aborted) throw abortReason(signal);
+    const uploadSignal = requestSignal(signal, this.#fileUploadTimeoutMs);
+    try {
+      return await this.#call('sendDocument', payload, {
+        signal: uploadSignal,
+        timeoutMs: this.#fileUploadTimeoutMs,
+        multipart: true,
+      });
+    } catch (error) {
+      if (signal?.aborted) throw abortReason(signal);
+      if (error?.code?.startsWith?.('telegram-')) {
+        throw telegramArtifactProviderError(error);
+      }
+      throw uncertainTelegramDelivery(error);
+    }
+  }
+
   async editMessageText({ chatId, messageId, text, signal }) {
     return this.#call('editMessageText', {
       chat_id: chatId,
@@ -144,15 +241,15 @@ export class TelegramApi {
     return this.#call('setChatMenuButton', { menu_button: menuButton }, { signal });
   }
 
-  async #call(method, payload, { signal, timeoutMs = 15_000 } = {}) {
+  async #call(method, payload, { signal, timeoutMs = 15_000, multipart = false } = {}) {
     const url = new URL(this.#baseUrl);
     url.pathname = `${url.pathname.replace(/\/$/, '')}/bot${this.#token}/${method}`;
     let response;
     try {
       response = await this.#fetch(url, {
         method: 'POST',
-        headers: { 'content-type': 'application/json' },
-        body: JSON.stringify(payload),
+        ...(multipart ? {} : { headers: { 'content-type': 'application/json' } }),
+        body: multipart ? payload : JSON.stringify(payload),
         signal: requestSignal(signal, timeoutMs),
         redirect: 'error',
       });
@@ -164,12 +261,21 @@ export class TelegramApi {
     try {
       body = await response.json();
     } catch {
-      throw new Error(`Telegram ${method} returned invalid JSON`);
+      const error = new Error(`Telegram ${method} returned invalid JSON`);
+      error.status = response?.status;
+      throw error;
     }
     if (!response.ok || body?.ok !== true) {
       const description = cleanString(body?.description);
       const error = new Error(description ?? `Telegram ${method} failed`);
       error.code = Number.isInteger(body?.error_code) ? `telegram-${body.error_code}` : 'telegram-api-error';
+      error.status = response.status;
+      if (Number.isInteger(body?.error_code)) error.providerCode = body.error_code;
+      const retryAfter = Number(body?.parameters?.retry_after);
+      if (Number.isFinite(retryAfter) && retryAfter >= 0) {
+        error.retry_after = retryAfter;
+        error.retryAfter = retryAfter;
+      }
       throw error;
     }
     return body.result;

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

@@ -146,7 +146,7 @@ export function telegramInboundAllowed(message, {
     && allowedPrivateUserIds.has(String(message.senderId));
 }
 
-class TelegramBotClient {
+export class TelegramBotClient {
   #api;
   #signal;
 
@@ -157,17 +157,20 @@ class TelegramBotClient {
 
   async sendText(target, text) {
     const chunks = splitMessageText(text, 4_000);
-    let result = null;
+    const providerMessageIds = [];
     for (const [index, chunk] of chunks.entries()) {
-      result = await this.#api.sendMessage({
+      const result = await this.#api.sendMessage({
         chatId: target.chatId,
         text: chunk,
         replyToMessageId: index === 0 ? target.replyToMessageId : undefined,
         messageThreadId: target.messageThreadId,
         signal: this.#signal,
       });
+      if (Number.isSafeInteger(result?.message_id)) {
+        providerMessageIds.push(String(result.message_id));
+      }
     }
-    return result;
+    return { providerMessageIds };
   }
 
   sendTyping(target) {
@@ -178,6 +181,16 @@ class TelegramBotClient {
     });
   }
 
+  sendFile(target, file) {
+    return this.#api.sendDocument({
+      chatId: target.chatId,
+      file,
+      replyToMessageId: target.replyToMessageId,
+      messageThreadId: target.messageThreadId,
+      signal: this.#signal,
+    });
+  }
+
   async openStream(target) {
     const stream = createEditableMessageStream({
       limit: 4_000,
@@ -203,6 +216,7 @@ class TelegramBotClient {
         messageThreadId: target.messageThreadId,
         signal: this.#signal,
       }),
+      messageIdForResult: (message) => message?.message_id,
     });
     return stream.start();
   }

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

@@ -27,6 +27,18 @@ import {
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
+import {
+  materializeOutboundArtifact,
+  releaseOutboundArtifact,
+  trackOutboundArtifactProviderPromise,
+} from '../shared/semantic/artifact.mjs';
+import {
+  createArtifactFailureReceipt,
+  createDeliveryReceipt,
+  mergeDeliveryReceipts,
+} from '../shared/semantic/delivery.mjs';
+
+const DEFAULT_FILE_UPLOAD_TIMEOUT_MS = 120_000;
 
 const HELP_TEXT = [
   '企业微信机器人已连接 DeepSeek Harness。',
@@ -212,6 +224,88 @@ function progressText(update) {
   return update?.text;
 }
 
+function artifactFailureText(fileName, error) {
+  const name = String(fileName ?? '结果文件').replace(/[\r\n]+/g, ' ').trim() || '结果文件';
+  switch (error?.code) {
+    case 'artifact-delivery-uncertain':
+      return `结果文件「${name}」的发送结果未能确认，请先检查聊天内是否已收到，不要立即重试。`;
+    case 'artifact-permission-required':
+      return `结果文件「${name}」已生成，但企业微信智能机器人缺少素材上传或文件消息能力，请检查机器人权限。`;
+    case 'artifact-too-large':
+      return `结果文件「${name}」超过当前企业微信机器人可发送的文件大小，未发送。`;
+    case 'artifact-empty':
+      return `结果文件「${name}」为空，企业微信不允许发送空文件。`;
+    case 'artifact-changed':
+    case 'artifact-invalid':
+    case 'artifact-unavailable':
+      return `结果文件「${name}」暂时无法读取或准备发送，请确认文件仍可访问后重试。`;
+    case 'artifact-rate-limited':
+      return `结果文件「${name}」暂时被企业微信限流，未能发送，请稍后重试。`;
+    case 'artifact-provider-rejected':
+      return `结果文件「${name}」已生成，但企业微信拒绝了该文件或文件消息。`;
+    default:
+      return `结果文件「${name}」已生成，但暂时未能通过企业微信发送，请稍后重试。`;
+  }
+}
+
+function abortReason(signal) {
+  return signal?.reason instanceof Error
+    ? signal.reason
+    : new DOMException('The operation was aborted', 'AbortError');
+}
+
+function waitWithSignal(promise, signal) {
+  if (!signal) return promise;
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener('abort', onAbort);
+      callback(value);
+    };
+    const onAbort = () => finish(reject, abortReason(signal));
+    signal.addEventListener('abort', onAbort, { once: true });
+    Promise.resolve(promise).then(
+      (value) => finish(resolve, value),
+      (error) => finish(reject, error),
+    );
+    if (signal.aborted) onAbort();
+  });
+}
+
+function wecomArtifactError(error, { dispatched = false } = {}) {
+  if (error?.code?.startsWith?.('artifact-')) return error;
+  const status = Number(error?.httpStatus ?? error?.status ?? error?.response?.status);
+  const providerCode = Number(error?.providerCode ?? error?.errcode ?? error?.body?.errcode);
+  const wrapped = new Error('Enterprise WeChat file delivery failed', { cause: error });
+  if (status === 401 || status === 403 || providerCode === 48002) {
+    wrapped.code = 'artifact-permission-required';
+  } else if (status === 413) {
+    wrapped.code = 'artifact-too-large';
+  } else if (status === 429 || providerCode === 45009) {
+    wrapped.code = 'artifact-rate-limited';
+  } else if (Number.isFinite(providerCode) && providerCode !== 0) {
+    wrapped.code = 'artifact-provider-rejected';
+  } else {
+    wrapped.code = dispatched ? 'artifact-delivery-uncertain' : 'artifact-provider-failed';
+  }
+  if (Number.isFinite(status)) wrapped.status = status;
+  if (Number.isFinite(providerCode)) wrapped.providerCode = providerCode;
+  return wrapped;
+}
+
+function answerTextForDelivery(answer, artifacts) {
+  if (typeof answer === 'string' && answer.trim()) return answer;
+  return artifacts.length > 0 ? '结果文件已生成。' : '任务已完成，但没有生成可显示的文本。';
+}
+
+function providerMessageId(result) {
+  return nonEmptyString(result?.body?.msgid)
+    ?? nonEmptyString(result?.body?.message_id);
+}
+
 function canClaimInteractionReply(frame, pending) {
   return pending.questions[pending.index]
     && nonEmptyString(bodyOf(frame).from?.userid) === pending.actor
@@ -223,6 +317,8 @@ export function createWecomBridgeStatus() {
     messagesReceived: 0,
     messagesReplied: 0,
     messagesRejected: 0,
+    artifactsSent: 0,
+    artifactSendErrors: 0,
     lastMessageAt: null,
     lastReplyAt: null,
     lastRejectedAt: null,
@@ -239,6 +335,7 @@ export class WecomHarnessBridge {
   #replyTimeoutMs;
   #generateReqId;
   #signal;
+  #fileUploadTimeoutMs;
   #queues = new Map();
   #pendingInteractions = new Map();
   #interactionKeys = new Map();
@@ -256,12 +353,16 @@ export class WecomHarnessBridge {
     logger = console,
     replyTimeoutMs = 600_000,
     generateStreamId = generateReqId,
+    fileUploadTimeoutMs = DEFAULT_FILE_UPLOAD_TIMEOUT_MS,
     signal,
   }) {
     if (!client || typeof client.replyStream !== 'function' || typeof client.sendMessage !== 'function') {
       throw new TypeError('Enterprise WeChat client is required');
     }
     if (!harness || !state) throw new TypeError('Harness client and state store are required');
+    if (!Number.isInteger(fileUploadTimeoutMs) || fileUploadTimeoutMs < 1) {
+      throw new TypeError('fileUploadTimeoutMs must be a positive integer');
+    }
     this.#client = client;
     this.#harness = harness;
     this.#state = state;
@@ -269,6 +370,7 @@ export class WecomHarnessBridge {
     this.#logger = logger;
     this.#replyTimeoutMs = replyTimeoutMs;
     this.#generateReqId = generateStreamId;
+    this.#fileUploadTimeoutMs = Math.min(fileUploadTimeoutMs, DEFAULT_FILE_UPLOAD_TIMEOUT_MS);
     this.#signal = signal;
     this.#approvals = new HarnessApprovalQueue({ label: 'wecom', logger });
   }
@@ -458,10 +560,17 @@ export class WecomHarnessBridge {
   }
 
   async #sendActive(chatId, text) {
+    const providerMessageIds = [];
     for (const chunk of splitUtf8(text)) {
       this.#signal?.throwIfAborted();
-      await this.#client.sendMessage(chatId, { msgtype: 'markdown', markdown: { content: chunk } });
+      const result = await this.#client.sendMessage(
+        chatId,
+        { msgtype: 'markdown', markdown: { content: chunk } },
+      );
+      const messageId = providerMessageId(result);
+      if (messageId) providerMessageIds.push(messageId);
     }
+    return providerMessageIds;
   }
 
   async #sendImmediate(frame, chatId, text) {
@@ -478,6 +587,105 @@ export class WecomHarnessBridge {
     }
   }
 
+  async #deliverArtifacts(chatId, replyTo, artifacts = [], baseReceipt = null) {
+    if (artifacts.length === 0) {
+      return { receipt: baseReceipt, failureNoticeVisible: false };
+    }
+    const receipts = baseReceipt ? [baseReceipt] : [];
+    let failureNoticeVisible = false;
+    for (const artifact of artifacts) {
+      this.#signal?.throwIfAborted();
+      try {
+        if (typeof this.#client.uploadMedia !== 'function'
+          || typeof this.#client.sendMediaMessage !== 'function') {
+          const unavailable = new Error('Enterprise WeChat file delivery is unavailable');
+          unavailable.code = 'artifact-provider-unavailable';
+          throw unavailable;
+        }
+        const file = await materializeOutboundArtifact(artifact, {
+          signal: this.#signal,
+        });
+        this.#signal?.throwIfAborted();
+        const timeout = AbortSignal.timeout(this.#fileUploadTimeoutMs);
+        const waitSignal = this.#signal ? AbortSignal.any([this.#signal, timeout]) : timeout;
+        let uploaded;
+        try {
+          const pending = this.#client.uploadMedia(file.bytes, {
+            type: 'file',
+            filename: file.fileName,
+          });
+          trackOutboundArtifactProviderPromise(file, pending);
+          uploaded = await waitWithSignal(pending, waitSignal);
+        } catch (error) {
+          if (this.#signal?.aborted) throw abortReason(this.#signal);
+          throw wecomArtifactError(error);
+        }
+        this.#signal?.throwIfAborted();
+        const mediaId = nonEmptyString(uploaded?.media_id);
+        if (!mediaId) {
+          const rejected = new Error('Enterprise WeChat upload returned no media id');
+          rejected.code = 'artifact-provider-rejected';
+          throw rejected;
+        }
+        let sent;
+        try {
+          const pending = this.#client.sendMediaMessage(chatId, 'file', mediaId);
+          trackOutboundArtifactProviderPromise(file, pending);
+          sent = await waitWithSignal(pending, waitSignal);
+        } catch (error) {
+          if (this.#signal?.aborted) throw abortReason(this.#signal);
+          throw wecomArtifactError(error, { dispatched: true });
+        }
+        this.#signal?.throwIfAborted();
+        const providerCode = Number(sent?.body?.errcode ?? sent?.errcode);
+        if (Number.isFinite(providerCode) && providerCode !== 0) {
+          throw wecomArtifactError({ providerCode });
+        }
+        const messageId = providerMessageId(sent);
+        receipts.push(createDeliveryReceipt({
+          deliveryId: file.deliveryKey,
+          presentation: 'wecom-file',
+          providerMessageIds: messageId ? [messageId] : [],
+          artifacts: [{ artifactId: file.artifactId, outcome: 'sent' }],
+        }));
+        this.#status.artifactsSent = (this.#status.artifactsSent ?? 0) + 1;
+      } catch (error) {
+        if (this.#signal?.aborted) throw error;
+        this.#status.artifactSendErrors = (this.#status.artifactSendErrors ?? 0) + 1;
+        this.#logger.warn?.(
+          `[dsh-im:wecom] result file delivery failed (${error?.code ?? 'unknown'})`,
+        );
+        let providerMessageIds = [];
+        try {
+          providerMessageIds = await this.#sendActive(
+            chatId,
+            artifactFailureText(artifact?.fileName, error),
+          );
+          failureNoticeVisible = true;
+        } catch (noticeError) {
+          if (this.#signal?.aborted) throw noticeError;
+          this.#logger.warn?.('[dsh-im:wecom] unable to send the safe result-file failure notice');
+        }
+        receipts.push(createArtifactFailureReceipt({
+          artifactId: artifact?.artifactId ?? 'unknown',
+          deliveryId: artifact?.deliveryKey ?? artifact?.artifactId ?? 'unknown',
+          error,
+          providerMessageIds,
+        }));
+      } finally {
+        releaseOutboundArtifact(artifact);
+      }
+    }
+    return {
+      receipt: mergeDeliveryReceipts({
+        deliveryId: replyTo,
+        presentation: baseReceipt ? 'wecom-text-and-files' : 'wecom-files',
+        receipts,
+      }),
+      failureNoticeVisible,
+    };
+  }
+
   async #process(frame, { alreadyRecorded = false, preparedMessage } = {}) {
     if (this.#signal?.aborted) return;
     const body = bodyOf(frame);
@@ -556,7 +764,7 @@ export class WecomHarnessBridge {
       const content = hasImages
         ? await promptContentForMessage(message, { signal: this.#signal })
         : undefined;
-      const { answer } = await askInWorkspaceSession({
+      const { answer, artifacts = [] } = await askInWorkspaceSession({
         harness: this.#harness,
         state: this.#state,
         key,
@@ -584,24 +792,64 @@ export class WecomHarnessBridge {
         },
       });
 
-      const chunks = splitUtf8(answer || '任务已完成，但没有生成可显示的文本。');
+      this.#signal?.throwIfAborted();
+      const displayAnswer = answerTextForDelivery(answer, artifacts);
+      const chunks = splitUtf8(displayAnswer);
       let finalSent = false;
-      if (streamStarted && chunks.length > 0) {
-        try {
-          await this.#client.replyStream(frame, streamId, chunks[0], true);
-          for (const chunk of chunks.slice(1)) {
-            await this.#client.sendMessage(chatId, { msgtype: 'markdown', markdown: { content: chunk } });
+      let textReceipt = null;
+      let textSendError = null;
+      try {
+        if (streamStarted && chunks.length > 0) {
+          try {
+            const providerMessageIds = [];
+            const streamed = await this.#client.replyStream(frame, streamId, chunks[0], true);
+            const streamedMessageId = providerMessageId(streamed);
+            if (streamedMessageId) providerMessageIds.push(streamedMessageId);
+            for (const chunk of chunks.slice(1)) {
+              const sent = await this.#client.sendMessage(
+                chatId,
+                { msgtype: 'markdown', markdown: { content: chunk } },
+              );
+              const messageId = providerMessageId(sent);
+              if (messageId) providerMessageIds.push(messageId);
+            }
+            finalSent = true;
+            textReceipt = createDeliveryReceipt({
+              deliveryId: messageId,
+              presentation: 'wecom-text',
+              providerMessageIds,
+            });
+          } catch (error) {
+            this.#logger.warn?.('[dsh-im:wecom] stream finalization failed; using an active reply:', error);
           }
-          finalSent = true;
-        } catch (error) {
-          this.#logger.warn?.('[dsh-im:wecom] stream finalization failed; using an active reply:', error);
         }
+        if (!finalSent) {
+          const providerMessageIds = await this.#sendActive(chatId, displayAnswer);
+          textReceipt = createDeliveryReceipt({
+            deliveryId: messageId,
+            presentation: 'wecom-text',
+            providerMessageIds,
+          });
+        }
+      } catch (error) {
+        textSendError = error;
+        this.#logger.warn?.(
+          '[dsh-im:wecom] final text delivery failed; continuing with result files:',
+          error,
+        );
+      }
+      const delivery = await this.#deliverArtifacts(chatId, messageId, artifacts, textReceipt);
+      const artifactDispatched = delivery.receipt?.artifacts?.some(
+        ({ outcome }) => outcome === 'sent' || outcome === 'unknown',
+      );
+      if (textSendError && !artifactDispatched && !delivery.failureNoticeVisible) {
+        throw textSendError;
       }
-      if (!finalSent) await this.#sendActive(chatId, answer);
       await this.#state.markSeen(messageId);
       this.#status.messagesReplied += 1;
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
+      return delivery.receipt;
     } catch (error) {
       if (error?.code === 'turn-stopped') {
         if (streamStarted && streamId) {