@xmanrui/dsh-im 1.0.2 → 1.2.0

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

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { extname } from 'node:path';
 
 import { fetchImageBuffer, ImagePromptError } from '../shared/image-prompt.mjs';
 
@@ -25,8 +26,67 @@ function nonEmptyString(value) {
 }
 
 function safeProviderCode(value) {
-  const code = nonEmptyString(value);
-  return code && /^[A-Za-z0-9_.:-]{1,160}$/.test(code) ? code : undefined;
+  const code = value === undefined || value === null ? null : String(value).trim();
+  return code && /^-?[A-Za-z0-9_.:-]{1,160}$/.test(code) ? code : undefined;
+}
+
+function preserveArtifactMetadata(target, source) {
+  if (Number.isInteger(source?.status)) target.status = source.status;
+  if (source?.providerCode !== undefined) target.providerCode = source.providerCode;
+  return target;
+}
+
+function dingtalkArtifactError(cause, { fallback = 'artifact-provider-rejected' } = {}) {
+  if (cause?.code?.startsWith?.('artifact-')) return cause;
+  const status = Number(cause?.status);
+  const providerCode = safeProviderCode(cause?.providerCode);
+  const providerText = providerCode ?? '';
+  let code = fallback;
+  let message = 'DingTalk could not prepare the file for delivery.';
+  if (status === 401 || status === 403 || providerCode === '401' || providerCode === '403'
+    || /(?:permission|forbidden|unauthor|access.?denied|\.auth(?:\.|$))/i.test(providerText)) {
+    code = 'artifact-permission-required';
+    message = 'DingTalk denied permission to send the file.';
+  } else if (status === 413 || providerCode === '413'
+    || /(?:too.?large|size.?limit)/i.test(providerText)) {
+    code = 'artifact-too-large';
+    message = 'The file exceeds DingTalk\'s size limit.';
+  } else if (status === 429 || providerCode === '429'
+    || /(?:rate.?limit|too.?many|throttl)/i.test(providerText)) {
+    code = 'artifact-rate-limited';
+    message = 'DingTalk rate-limited file delivery.';
+  } else if (fallback === 'artifact-provider-rejected') {
+    message = 'DingTalk rejected the file message.';
+  }
+  const error = new Error(message, { cause });
+  error.code = code;
+  return preserveArtifactMetadata(error, cause);
+}
+
+function uncertainDingtalkDelivery(cause) {
+  const error = new Error('DingTalk file delivery result is uncertain', { cause });
+  error.code = 'artifact-delivery-uncertain';
+  return preserveArtifactMetadata(error, cause);
+}
+
+function rejectedProviderResponse(value) {
+  if (!value || typeof value !== 'object') return null;
+  for (const field of ['errcode', 'code']) {
+    if (value[field] !== undefined && value[field] !== 0 && value[field] !== '0') {
+      return safeProviderCode(value[field]) ?? 'rejected';
+    }
+  }
+  return null;
+}
+
+function classifyDingtalkFinalDeliveryError(error, signal) {
+  if (signal?.aborted) throw abortError(signal);
+  const status = Number(error?.status);
+  if (error?.code === 'network-error' || error?.code === 'timeout'
+    || error?.code === 'invalid-response' || (status >= 500 && status < 600)) {
+    return uncertainDingtalkDelivery(error);
+  }
+  return dingtalkArtifactError(error);
 }
 
 function secureDingtalkDownloadUrl(value) {
@@ -174,6 +234,74 @@ async function requestJson(fetchImpl, url, {
   }
 }
 
+async function requestMultipart(fetchImpl, url, { body, signal, timeoutMs = 60_000 } = {}) {
+  const controller = new AbortController();
+  let timedOut = false;
+  const onAbort = () => controller.abort(signal?.reason);
+  if (signal?.aborted) throw abortError(signal);
+  signal?.addEventListener('abort', onAbort, { once: true });
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
+  try {
+    const response = await fetchImpl(url, {
+      method: 'POST',
+      body,
+      signal: controller.signal,
+      redirect: 'error',
+    });
+    let value;
+    let parseError;
+    try {
+      value = await response.json();
+    } catch (error) {
+      parseError = error;
+    }
+    if (!response.ok) {
+      throw new DingtalkApiError(
+        'http-error',
+        `钉钉服务请求失败（HTTP ${response.status}）。`,
+        { status: response.status, providerCode: safeProviderCode(value?.code ?? value?.errcode) },
+      );
+    }
+    if (parseError) {
+      throw new DingtalkApiError(
+        'invalid-response',
+        '钉钉服务返回了无法解析的响应。',
+        { cause: parseError },
+      );
+    }
+    return value;
+  } catch (error) {
+    if (signal?.aborted) throw abortError(signal);
+    if (timedOut) throw new DingtalkApiError('timeout', '钉钉服务请求超时。', { cause: error });
+    if (error instanceof DingtalkApiError) throw error;
+    throw new DingtalkApiError('network-error', '暂时无法完成钉钉文件上传请求。', { cause: error });
+  } finally {
+    clearTimeout(timer);
+    signal?.removeEventListener('abort', onAbort);
+  }
+}
+
+function normalizeFileTarget(target) {
+  const robotCode = nonEmptyString(target?.robotCode);
+  if (!robotCode) throw new TypeError('DingTalk robotCode is required');
+  if (target?.type === 'group') {
+    const openConversationId = nonEmptyString(target.openConversationId);
+    if (openConversationId) return { type: 'group', robotCode, openConversationId };
+  }
+  if (target?.type === 'user') {
+    const userId = nonEmptyString(target.userId);
+    if (userId) return { type: 'user', robotCode, userId };
+  }
+  throw new TypeError('DingTalk file target is invalid');
+}
+
+function dingtalkFileType(fileName) {
+  return extname(fileName).slice(1).toLowerCase();
+}
+
 function normalizeCardTarget(target) {
   if (target?.type === 'user') {
     const userId = nonEmptyString(target.userId);
@@ -648,6 +776,91 @@ export function createDingtalkApi({
       return true;
     },
 
+    async sendFile({ clientId, clientSecret, target, file, signal }) {
+      if (!file || typeof file !== 'object'
+        || typeof file.fileName !== 'string' || !file.fileName
+        || !Buffer.isBuffer(file.bytes)) {
+        throw new TypeError('A DingTalk file is required');
+      }
+      const normalizedTarget = normalizeFileTarget(target);
+      const fileType = dingtalkFileType(file.fileName);
+      let token;
+      try {
+        token = await accessToken({ clientId, clientSecret, signal });
+      } catch (error) {
+        if (signal?.aborted) throw abortError(signal);
+        const status = Number(error?.status);
+        const fallback = error?.code === 'http-error' && status >= 400 && status < 500
+          ? 'artifact-provider-rejected'
+          : 'artifact-provider-failed';
+        throw dingtalkArtifactError(error, { fallback });
+      }
+      const uploadUrl = new URL('media/upload', DINGTALK_REGISTRATION_BASE_URL);
+      uploadUrl.searchParams.set('access_token', token);
+      uploadUrl.searchParams.set('type', 'file');
+      const form = new FormData();
+      form.append(
+        'media',
+        new Blob([file.bytes], { type: file.mediaType ?? 'application/octet-stream' }),
+        file.fileName,
+      );
+      let uploaded;
+      try {
+        uploaded = await requestMultipart(fetchImpl, uploadUrl, { body: form, signal });
+      } catch (error) {
+        if (signal?.aborted) throw abortError(signal);
+        const status = Number(error?.status);
+        const fallback = error?.code === 'http-error' && status >= 400 && status < 500
+          ? 'artifact-provider-rejected'
+          : 'artifact-provider-failed';
+        throw dingtalkArtifactError(error, { fallback });
+      }
+      const uploadRejection = rejectedProviderResponse(uploaded);
+      if (uploadRejection || !nonEmptyString(uploaded?.media_id)) {
+        throw dingtalkArtifactError(new DingtalkApiError(
+          'upload-rejected',
+          '钉钉服务拒绝了文件上传。',
+          { providerCode: uploadRejection ?? 'missing-media-id' },
+        ));
+      }
+      signal?.throwIfAborted();
+      const messageBody = {
+        robotCode: normalizedTarget.robotCode,
+        msgKey: 'sampleFile',
+        msgParam: JSON.stringify({
+          mediaId: uploaded.media_id,
+          fileName: file.fileName,
+          fileType,
+        }),
+        ...(normalizedTarget.type === 'group'
+          ? { openConversationId: normalizedTarget.openConversationId }
+          : { userIds: [normalizedTarget.userId] }),
+      };
+      const pathname = normalizedTarget.type === 'group'
+        ? 'v1.0/robot/groupMessages/send'
+        : 'v1.0/robot/oToMessages/batchSend';
+      let response;
+      try {
+        response = await requestJson(fetchImpl, endpoint(apiBase, pathname), {
+          body: messageBody,
+          headers: { 'x-acs-dingtalk-access-token': token },
+          signal,
+          action: '文件消息发送',
+        });
+      } catch (error) {
+        throw classifyDingtalkFinalDeliveryError(error, signal);
+      }
+      const sendRejection = rejectedProviderResponse(response);
+      if (sendRejection) {
+        throw dingtalkArtifactError(new DingtalkApiError(
+          'send-rejected',
+          '钉钉服务拒绝了文件消息。',
+          { providerCode: sendRejection },
+        ));
+      }
+      return response;
+    },
+
     clearAccessToken(clientId) {
       const appKey = nonEmptyString(clientId);
       if (appKey) tokenCache.delete(appKey);

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;