@xmanrui/dsh-im 1.0.2 → 1.1.0

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

@@ -30,6 +30,16 @@ import {
   promptContentForMessage,
 } from '../shared/image-prompt.mjs';
 import { rememberConnectionTestTarget } from '../shared/connection-test.mjs';
+import {
+  materializeOutboundArtifact,
+  releaseOutboundArtifact,
+} from '../shared/semantic/artifact.mjs';
+import {
+  createArtifactFailureReceipt,
+  createDeliveryReceipt,
+  mergeDeliveryReceipts,
+  providerMessageIdsFor,
+} from '../shared/semantic/delivery.mjs';
 
 const CARD_INITIAL_TEXT = '已连接 DeepSeek Harness，正在思考…';
 const CARD_ERROR_TEXT = '消息处理失败，请稍后重试。';
@@ -62,6 +72,13 @@ function nonEmptyString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
 }
 
+function dingtalkFileProviderIds(result) {
+  const ids = providerMessageIdsFor(result);
+  const processQueryKey = nonEmptyString(result?.processQueryKey);
+  if (processQueryKey && !ids.includes(processQueryKey)) ids.push(processQueryKey);
+  return ids;
+}
+
 function safeErrorDiagnostic(error) {
   const chain = [];
   const seen = new Set();
@@ -195,6 +212,40 @@ function cardTarget(message, sender) {
   return { type: 'user', userId: sender };
 }
 
+function fileTarget(message, sender, clientId) {
+  const robotCode = nonEmptyString(message?.robotCode) ?? clientId;
+  if (String(message?.conversationType) === '2') {
+    return {
+      type: 'group',
+      openConversationId: nonEmptyString(message?.conversationId),
+      robotCode,
+    };
+  }
+  return { type: 'user', userId: sender, robotCode };
+}
+
+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}」已生成，但钉钉应用或机器人缺少文件消息权限。请开通应用 qyapi_base 权限，并确认机器人具备文件消息发送能力。`;
+    case 'artifact-too-large':
+      return `结果文件「${name}」超过当前钉钉机器人可发送的文件大小，未发送。`;
+    case 'artifact-rate-limited':
+      return `结果文件「${name}」暂时被钉钉限流，未能发送，请稍后重试。`;
+    case 'artifact-provider-rejected':
+      return `结果文件「${name}」已生成，但钉钉拒绝了该文件消息，请检查文件类型和机器人文件消息配置。`;
+    case 'artifact-invalid':
+    case 'artifact-changed':
+    case 'artifact-unavailable':
+      return `结果文件「${name}」暂时无法读取或准备发送，请确认文件仍可访问后重试。`;
+    default:
+      return `结果文件「${name}」已生成，但暂时未能通过钉钉发送，请稍后重试。`;
+  }
+}
+
 function progressText(update) {
   if (update?.type === 'text' && nonEmptyString(update.text)) return update.text;
   if (update?.type === 'tool') {
@@ -596,7 +647,7 @@ export class DingtalkHarnessBridge {
         });
         cardStarted = await cardStream.start(CARD_INITIAL_TEXT);
       }
-      const { answer } = await askInWorkspaceSession({
+      const { answer, artifacts = [] } = await askInWorkspaceSession({
         harness: this.#harness,
         state: this.#state,
         key,
@@ -619,11 +670,41 @@ export class DingtalkHarnessBridge {
           onInteractionResolved: (resolution) => this.#handleInteractionResolved(resolution),
         },
       });
-      const streamed = cardStarted && await cardStream.finish(answer);
-      if (!streamed) await this.#send(sessionWebhook, answer);
+      const answerText = typeof answer === 'string' && answer.trim()
+        ? answer
+        : artifacts.length > 0 ? '结果文件已生成。' : answer;
+      let textDeliveryError = null;
+      let textReceipt = null;
+      let streamed = false;
+      try {
+        streamed = cardStarted && await cardStream.finish(answerText);
+        if (streamed) {
+          textReceipt = createDeliveryReceipt({
+            deliveryId: messageId,
+            presentation: 'dingtalk-card',
+          });
+        } else {
+          textReceipt = createDeliveryReceipt({
+            deliveryId: messageId,
+            presentation: 'dingtalk-text',
+            providerMessageIds: await this.#send(sessionWebhook, answerText),
+          });
+        }
+      } catch (error) {
+        textDeliveryError = error;
+      }
+      const delivery = await this.#deliverArtifacts(
+        fileTarget(message, sender, this.#clientId),
+        sessionWebhook,
+        messageId,
+        artifacts,
+        textReceipt,
+      );
+      if (textDeliveryError && !delivery.userVisible) throw textDeliveryError;
       increment(this.#status, 'messagesReplied');
       this.#status.lastReplyAt = new Date().toISOString();
       this.#status.lastError = null;
+      return delivery.receipt;
     } catch (error) {
       if (error?.code === 'turn-stopped') {
         if (cardStarted) await cardStream.finish('已停止。').catch(() => undefined);
@@ -940,16 +1021,86 @@ export class DingtalkHarnessBridge {
   }
 
   async #send(sessionWebhook, text) {
+    const providerMessageIds = [];
     for (const chunk of splitDingtalkText(text, this.#maxMessageChars)) {
       this.#signal?.throwIfAborted();
-      await this.#api.sendText({
+      const result = await this.#api.sendText({
         clientId: this.#clientId,
         clientSecret: this.#clientSecret,
         sessionWebhook,
         text: chunk,
         signal: this.#signal,
       });
+      providerMessageIds.push(...providerMessageIdsFor(result));
+    }
+    return providerMessageIds;
+  }
+
+  async #deliverArtifacts(target, sessionWebhook, replyTo, artifacts, baseReceipt) {
+    const receipts = baseReceipt ? [baseReceipt] : [];
+    let userVisible = Boolean(baseReceipt);
+    for (const artifact of artifacts) {
+      this.#signal?.throwIfAborted();
+      try {
+        if (typeof this.#api.sendFile !== 'function') {
+          const unavailable = new Error('DingTalk file delivery is unavailable');
+          unavailable.code = 'artifact-provider-unavailable';
+          throw unavailable;
+        }
+        const file = await materializeOutboundArtifact(artifact, {
+          signal: this.#signal,
+        });
+        const result = await this.#api.sendFile({
+          clientId: this.#clientId,
+          clientSecret: this.#clientSecret,
+          target,
+          file,
+          signal: this.#signal,
+        });
+        receipts.push(createDeliveryReceipt({
+          deliveryId: file.deliveryKey,
+          presentation: 'dingtalk-file',
+          providerMessageIds: dingtalkFileProviderIds(result),
+          artifacts: [{ artifactId: file.artifactId, outcome: 'sent' }],
+        }));
+        userVisible = true;
+        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-dingtalk] result file delivery failed (${error?.code ?? 'unknown'})`,
+        );
+        let noticeSent = false;
+        const providerMessageIds = await this.#send(
+          sessionWebhook,
+          artifactFailureText(artifact?.fileName, error),
+        ).then((ids) => {
+          noticeSent = true;
+          return ids;
+        }).catch(() => []);
+        const failureReceipt = createArtifactFailureReceipt({
+          artifactId: artifact?.artifactId ?? 'unknown',
+          deliveryId: artifact?.deliveryKey ?? artifact?.artifactId ?? 'unknown',
+          error,
+          providerMessageIds,
+        });
+        receipts.push(failureReceipt);
+        if (noticeSent || failureReceipt.artifacts[0]?.outcome === 'unknown') userVisible = true;
+      } finally {
+        releaseOutboundArtifact(artifact);
+      }
     }
+    const receipt = receipts.length === 0
+      ? null
+      : receipts.length === 1
+        ? receipts[0]
+        : mergeDeliveryReceipts({
+            deliveryId: replyTo,
+            presentation: baseReceipt ? 'dingtalk-text-and-files' : 'dingtalk-files',
+            receipts,
+          });
+    return { receipt, userVisible };
   }
 }
 

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

@@ -1,4 +1,9 @@
+import { createHash } from 'node:crypto';
+
 const DEFAULT_BASE_URL = 'https://discord.com/api/v10/';
+const DEFAULT_FILE_UPLOAD_TIMEOUT_MS = 120_000;
+const DISCORD_PERMISSION_ERRORS = new Set([50001, 50013]);
+const DISCORD_TOO_LARGE_ERRORS = new Set([40005]);
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -9,6 +14,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 discordArtifactProviderError(cause) {
+  const providerCode = Number(cause?.providerCode);
+  const status = Number(cause?.status);
+  const message = cleanString(cause?.message) ?? '';
+  let code = 'artifact-provider-rejected';
+  let summary = 'Discord rejected the attachment.';
+  if (status === 401 || status === 403 || DISCORD_PERMISSION_ERRORS.has(providerCode)) {
+    code = 'artifact-permission-required';
+    summary = 'Discord denied permission to send the attachment.';
+  } else if (status === 413 || DISCORD_TOO_LARGE_ERRORS.has(providerCode)
+    || /(?:request|attachment|file).{0,24}too large/i.test(message)) {
+    code = 'artifact-too-large';
+    summary = 'The attachment exceeds Discord\'s size limit.';
+  } else if (status === 429) {
+    code = 'artifact-rate-limited';
+    summary = 'Discord rate-limited attachment delivery.';
+  } else if (status >= 500) {
+    code = 'artifact-delivery-uncertain';
+    summary = 'Discord attachment delivery result is uncertain.';
+  }
+  const error = new Error(summary, { cause });
+  error.code = code;
+  return preserveProviderMetadata(error, cause);
+}
+
+function uncertainDiscordDelivery(cause) {
+  const error = new Error('Discord attachment delivery result is uncertain', { cause });
+  error.code = 'artifact-delivery-uncertain';
+  return preserveProviderMetadata(error, cause);
+}
+
 function delay(ms, signal) {
   return new Promise((resolve, reject) => {
     if (signal?.aborted) {
@@ -39,13 +96,20 @@ export class DiscordApi {
   #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 (!validDiscordToken(token)) throw new TypeError('Discord Bot Token is invalid');
     if (typeof fetchImpl !== 'function') throw new TypeError('DiscordApi requires fetch');
     this.#token = token.trim();
     this.#fetch = fetchImpl;
     this.#baseUrl = new URL(baseUrl);
+    this.#fileUploadTimeoutMs = positiveTimeout(fileUploadTimeoutMs, 'fileUploadTimeoutMs');
   }
 
   getCurrentUser(options = {}) {
@@ -74,6 +138,54 @@ export class DiscordApi {
     });
   }
 
+  async createFileMessage({ channelId, file, replyToMessageId, signal }) {
+    if (!file || typeof file !== 'object'
+      || typeof file.fileName !== 'string' || !file.fileName
+      || !Buffer.isBuffer(file.bytes)) {
+      throw new TypeError('A Discord attachment is required');
+    }
+    const deliverySeed = cleanString(file.deliveryKey) ?? cleanString(file.artifactId);
+    const nonce = deliverySeed
+      ? createHash('sha256').update(deliverySeed).digest('hex').slice(0, 25)
+      : undefined;
+    const payload = new FormData();
+    payload.append('payload_json', JSON.stringify({
+      allowed_mentions: { parse: [], replied_user: false },
+      attachments: [{ id: 0, filename: file.fileName }],
+      ...(nonce ? { nonce, enforce_nonce: true } : {}),
+      ...(replyToMessageId ? {
+        message_reference: {
+          message_id: snowflake(replyToMessageId, 'message id'),
+          channel_id: snowflake(channelId, 'channel id'),
+          fail_if_not_exists: false,
+        },
+      } : {}),
+    }));
+    payload.append(
+      'files[0]',
+      new Blob([file.bytes], { type: file.mediaType ?? 'application/octet-stream' }),
+      file.fileName,
+    );
+    const targetChannelId = snowflake(channelId, 'channel id');
+    if (signal?.aborted) throw abortReason(signal);
+    const uploadSignal = requestSignal(signal, this.#fileUploadTimeoutMs);
+    try {
+      return await this.#request(`channels/${targetChannelId}/messages`, {
+        method: 'POST',
+        signal: uploadSignal,
+        timeoutMs: this.#fileUploadTimeoutMs,
+        body: payload,
+        multipart: true,
+      });
+    } catch (error) {
+      if (signal?.aborted) throw abortReason(signal);
+      if (error?.code?.startsWith?.('discord-')) {
+        throw discordArtifactProviderError(error);
+      }
+      throw uncertainDiscordDelivery(error);
+    }
+  }
+
   editMessage({ channelId, messageId, content, signal }) {
     return this.#request(
       `channels/${snowflake(channelId, 'channel id')}/messages/${snowflake(messageId, 'message id')}`,
@@ -100,6 +212,7 @@ export class DiscordApi {
     timeoutMs = 15_000,
     expectBody = true,
     retry = true,
+    multipart = false,
   }) {
     let response;
     try {
@@ -107,10 +220,10 @@ export class DiscordApi {
         method,
         headers: {
           authorization: `Bot ${this.#token}`,
-          'content-type': 'application/json',
-          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 1.0.2)',
+          ...(multipart ? {} : { 'content-type': 'application/json' }),
+          'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 1.1.0)',
         },
-        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        ...(body === undefined ? {} : { body: multipart ? body : JSON.stringify(body) }),
         signal: requestSignal(signal, timeoutMs),
         redirect: 'error',
       });
@@ -124,17 +237,32 @@ export class DiscordApi {
       try {
         parsed = await response.json();
       } catch {
-        if (expectBody) throw new Error(`Discord ${method} returned invalid JSON`);
+        if (expectBody) {
+          const error = new Error(`Discord ${method} returned invalid JSON`);
+          error.status = response?.status;
+          throw error;
+        }
       }
     }
     if (response.status === 429 && retry) {
       const retryAfterMs = Math.min(10_000, Math.max(50, Number(parsed?.retry_after) * 1_000 || 1_000));
       await delay(retryAfterMs, signal);
-      return this.#request(path, { method, body, signal, timeoutMs, expectBody, retry: false });
+      return this.#request(path, {
+        method, body, signal, timeoutMs, expectBody, retry: false, multipart,
+      });
     }
     if (!response.ok) {
       const error = new Error(cleanString(parsed?.message) ?? `Discord API failed with HTTP ${response.status}`);
       error.code = `discord-${response.status}`;
+      error.status = response.status;
+      if (Number.isInteger(parsed?.code) || typeof parsed?.code === 'string') {
+        error.providerCode = parsed.code;
+      }
+      const retryAfter = Number(parsed?.retry_after);
+      if (Number.isFinite(retryAfter) && retryAfter >= 0) {
+        error.retry_after = retryAfter;
+        error.retryAfter = retryAfter;
+      }
       throw error;
     }
     return expectBody ? parsed : null;

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

@@ -112,7 +112,7 @@ export function normalizeDiscordMessage(message, botId, { fetchImpl = fetch } =
   };
 }
 
-class DiscordBotClient {
+export class DiscordBotClient {
   #api;
   #signal;
 
@@ -123,22 +123,32 @@ class DiscordBotClient {
 
   async sendText(target, text) {
     const chunks = splitMessageText(text, 1_900);
-    let result = null;
+    const providerMessageIds = [];
     for (const [index, chunk] of chunks.entries()) {
-      result = await this.#api.createMessage({
+      const result = await this.#api.createMessage({
         channelId: target.channelId,
         content: chunk,
         replyToMessageId: index === 0 ? target.replyToMessageId : undefined,
         signal: this.#signal,
       });
+      if (typeof result?.id === 'string' && result.id) providerMessageIds.push(result.id);
     }
-    return result;
+    return { providerMessageIds };
   }
 
   sendTyping(target) {
     return this.#api.sendTyping({ channelId: target.channelId, signal: this.#signal });
   }
 
+  sendFile(target, file) {
+    return this.#api.createFileMessage({
+      channelId: target.channelId,
+      file,
+      replyToMessageId: target.replyToMessageId,
+      signal: this.#signal,
+    });
+  }
+
   async openStream(target) {
     const stream = createEditableMessageStream({
       limit: 1_900,
@@ -162,6 +172,7 @@ class DiscordBotClient {
         content,
         signal: this.#signal,
       }),
+      messageIdForResult: (message) => message?.id,
     });
     return stream.start();
   }