@xmanrui/dsh-im 1.0.2 → 1.2.0

package/src/channels/shared/semantic/delivery.mjs

@@ -0,0 +1,153 @@
+export const DELIVERY_RECEIPT_SCHEMA_VERSION = 1;
+
+const ARTIFACT_OUTCOMES = new Set(['sent', 'rejected', 'failed', 'unknown']);
+const REJECTED_ARTIFACT_ERRORS = new Set([
+  'artifact-changed',
+  'artifact-context-required',
+  'artifact-empty',
+  'artifact-invalid',
+  'artifact-not-file',
+  'artifact-permission-required',
+  'artifact-provider-rejected',
+  'artifact-too-large',
+  'artifact-unavailable',
+]);
+
+export function providerMessageIdsFor(value) {
+  if (!value || typeof value !== 'object') return [];
+  const ids = Array.isArray(value.providerMessageIds)
+    ? value.providerMessageIds
+      .filter((candidate) => (
+        (typeof candidate === 'string' && candidate.trim())
+          || Number.isSafeInteger(candidate)
+      ))
+      .map(String)
+    : [];
+  const candidates = [
+    value.message_id,
+    value.messageId,
+    value.id,
+    value.ts,
+    value.message?.message_id,
+    value.message?.messageId,
+    value.message?.id,
+    value.message?.ts,
+    value.key?.id,
+    value.data?.message_id,
+  ];
+  const id = candidates.find((candidate) => (
+    (typeof candidate === 'string' && candidate.trim())
+      || Number.isSafeInteger(candidate)
+  ));
+  if (id !== undefined) ids.push(String(id));
+  return [...new Set(ids)];
+}
+
+function requiredString(value, name) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new TypeError(`${name} must be a non-empty string`);
+  }
+  return value;
+}
+
+function providerIds(values) {
+  if (!Array.isArray(values)) throw new TypeError('providerMessageIds must be an array');
+  const ids = [];
+  const seen = new Set();
+  for (const value of values) {
+    const id = requiredString(value, 'providerMessageId');
+    if (seen.has(id)) continue;
+    seen.add(id);
+    ids.push(id);
+  }
+  return Object.freeze(ids);
+}
+
+function artifactResults(values) {
+  if (!Array.isArray(values)) throw new TypeError('artifacts must be an array');
+  return Object.freeze(values.map((value) => {
+    if (!value || typeof value !== 'object') {
+      throw new TypeError('artifact result must be an object');
+    }
+    const artifactId = requiredString(value.artifactId, 'artifactId');
+    if (!ARTIFACT_OUTCOMES.has(value.outcome)) {
+      throw new TypeError('artifact outcome must be sent, rejected, failed, or unknown');
+    }
+    const reason = value.reason === undefined
+      ? undefined
+      : requiredString(value.reason, 'artifact reason');
+    return Object.freeze({
+      artifactId,
+      outcome: value.outcome,
+      ...(reason === undefined ? {} : { reason }),
+    });
+  }));
+}
+
+export function artifactOutcomeForError(error) {
+  const code = typeof error === 'string' ? error : error?.code;
+  if (code === 'artifact-delivery-uncertain') return 'unknown';
+  if (REJECTED_ARTIFACT_ERRORS.has(code)) return 'rejected';
+  return 'failed';
+}
+
+export function createDeliveryReceipt({
+  deliveryId,
+  presentation,
+  providerMessageIds = [],
+  artifacts = [],
+}) {
+  return Object.freeze({
+    schemaVersion: DELIVERY_RECEIPT_SCHEMA_VERSION,
+    deliveryId: requiredString(deliveryId, 'deliveryId'),
+    presentation: requiredString(presentation, 'presentation'),
+    providerMessageIds: providerIds(providerMessageIds),
+    artifacts: artifactResults(artifacts),
+  });
+}
+
+export function createArtifactFailureReceipt({
+  artifactId,
+  deliveryId,
+  error,
+  presentation = 'text-fallback',
+  providerMessageIds = [],
+}) {
+  const code = typeof error === 'string' ? error : error?.code;
+  const reason = typeof code === 'string' && code
+    ? code
+    : 'artifact-provider-failed';
+  return createDeliveryReceipt({
+    deliveryId,
+    presentation,
+    providerMessageIds,
+    artifacts: [{
+      artifactId,
+      outcome: artifactOutcomeForError(error),
+      reason,
+    }],
+  });
+}
+
+export function mergeDeliveryReceipts({ deliveryId, presentation, receipts }) {
+  if (!Array.isArray(receipts) || receipts.length === 0) {
+    throw new TypeError('receipts must contain at least one delivery receipt');
+  }
+  const messageIds = [];
+  const artifacts = new Map();
+  for (const receipt of receipts) {
+    if (!receipt || receipt.schemaVersion !== DELIVERY_RECEIPT_SCHEMA_VERSION) {
+      throw new TypeError('receipt must use DeliveryReceipt schema version 1');
+    }
+    messageIds.push(...(receipt.providerMessageIds ?? []));
+    for (const artifact of receipt.artifacts ?? []) {
+      artifacts.set(artifact.artifactId, artifact);
+    }
+  }
+  return createDeliveryReceipt({
+    deliveryId,
+    presentation,
+    providerMessageIds: messageIds,
+    artifacts: [...artifacts.values()],
+  });
+}

package/src/channels/shared/text-harness-bridge.mjs

@@ -28,8 +28,19 @@ import {
   harnessQuestionText,
   validHarnessQuestion,
 } from './harness-question.mjs';
+import {
+  materializeOutboundArtifact,
+  releaseOutboundArtifact,
+} from './semantic/artifact.mjs';
+import {
+  createArtifactFailureReceipt,
+  createDeliveryReceipt,
+  mergeDeliveryReceipts,
+  providerMessageIdsFor,
+} from './semantic/delivery.mjs';
 
 const INTERACTION_RESOLVED_TEXT = '这个问题已在其他客户端处理，无需再次回答。';
+const FILE_ONLY_COMPLETION_TEXT = '任务已完成。';
 
 function cleanText(value) {
   return typeof value === 'string' ? value.trim() : '';
@@ -42,6 +53,42 @@ function canClaimInteractionReply(message, pending, senderId) {
     && Boolean(cleanText(message.content));
 }
 
+function artifactFailureText(fileName, error, descriptor) {
+  const name = String(fileName ?? '结果文件')
+    .replace(/[\r\n]+/g, ' ')
+    .trim()
+    .slice(0, 255) || '结果文件';
+  switch (error?.code) {
+    case 'artifact-delivery-uncertain':
+      return `结果文件「${name}」的发送结果未能确认，请先检查聊天内是否已收到，不要立即重试。`;
+    case 'artifact-permission-required':
+      if (descriptor?.key === 'slack') {
+        return `结果文件「${name}」已生成，但 Slack 应用缺少 files:write 权限。请更新 Manifest、重新安装应用并重新连接机器人后重试。`;
+      }
+      if (descriptor?.key === 'discord') {
+        return `结果文件「${name}」已生成，但机器人缺少 Discord 的 Send Messages、Attach Files 或 Read Message History 权限。`;
+      }
+      if (descriptor?.key === 'telegram') {
+        return `结果文件「${name}」已生成，但 Telegram 不允许机器人在当前聊天发送文档，请检查聊天权限。`;
+      }
+      return `结果文件「${name}」已生成，但当前机器人没有文件发送权限，请检查渠道权限。`;
+    case 'artifact-too-large':
+      return `结果文件「${name}」超过当前渠道大小上限，未发送。`;
+    case 'artifact-empty':
+      return `结果文件「${name}」为空，未发送。`;
+    case 'artifact-invalid':
+    case 'artifact-changed':
+    case 'artifact-unavailable':
+      return `结果文件「${name}」暂时无法读取或准备发送，请确认文件仍可访问后重试。`;
+    case 'artifact-rate-limited':
+      return `结果文件「${name}」暂时被当前渠道限流，未能发送，请稍后重试。`;
+    case 'artifact-provider-rejected':
+      return `结果文件「${name}」已生成，但当前渠道拒绝了该文件或文件消息。`;
+    default:
+      return `结果文件「${name}」已生成，但当前渠道暂时未能发送，请稍后重试。`;
+  }
+}
+
 export function createTextBridgeStatus() {
   return {
     messagesReceived: 0,
@@ -285,6 +332,76 @@ export class TextHarnessBridge {
     });
   }
 
+  async #deliverArtifacts(target, replyTo, artifacts = [], baseReceipt) {
+    const receipts = baseReceipt ? [baseReceipt] : [];
+    let userVisible = Boolean(baseReceipt);
+    for (const artifact of artifacts) {
+      this.#signal?.throwIfAborted();
+      try {
+        if (typeof this.#bot.sendFile !== 'function') {
+          const unavailable = new Error('Native file delivery is unavailable');
+          unavailable.code = 'artifact-provider-unavailable';
+          throw unavailable;
+        }
+        const file = await materializeOutboundArtifact(artifact, {
+          signal: this.#signal,
+        });
+        this.#signal?.throwIfAborted();
+        const result = await this.#bot.sendFile(target, file);
+        receipts.push(createDeliveryReceipt({
+          deliveryId: file.deliveryKey,
+          presentation: `${this.#descriptor.key}-file`,
+          providerMessageIds: providerMessageIdsFor(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-im:${this.#descriptor.key}] result file delivery failed (${error?.code ?? 'unknown'})`,
+        );
+        let providerMessageIds = [];
+        let noticeSent = false;
+        try {
+          const notice = await this.#bot.sendText(
+            target,
+            artifactFailureText(artifact?.fileName, error, this.#descriptor),
+          );
+          providerMessageIds = providerMessageIdsFor(notice);
+          noticeSent = true;
+        } catch {
+          this.#logger.warn?.(
+            `[dsh-im:${this.#descriptor.key}] unable to send the safe result-file failure notice`,
+          );
+        }
+        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
+              ? `${this.#descriptor.key}-text-and-files`
+              : `${this.#descriptor.key}-files`,
+            receipts,
+          });
+    return { receipt, userVisible };
+  }
+
   async #process(message, messageId, senderId, conversationKey, {
     alreadyRecorded = false,
   } = {}) {
@@ -386,7 +503,7 @@ export class TextHarnessBridge {
       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: conversationKey,
@@ -412,10 +529,23 @@ export class TextHarnessBridge {
           onInteractionResolved: (resolution) => this.#handleInteractionResolved(resolution),
         },
       });
+      const visibleAnswer = !cleanText(answer) && artifacts.length > 0
+        ? FILE_ONLY_COMPLETION_TEXT
+        : answer;
+      let textDeliveryError = null;
+      let textReceipt = null;
       if (stream) {
         try {
-          await stream.finish(answer);
+          const result = await stream.finish(visibleAnswer);
           streamFinished = true;
+          textReceipt = createDeliveryReceipt({
+            deliveryId: messageId,
+            presentation: `${this.#descriptor.key}-stream`,
+            providerMessageIds: [
+              ...providerMessageIdsFor(stream),
+              ...providerMessageIdsFor(result),
+            ],
+          });
         } catch (error) {
           stream.cancel?.();
           this.#logger.warn?.(
@@ -424,10 +554,26 @@ export class TextHarnessBridge {
           );
         }
       }
-      if (!streamFinished) await this.#bot.sendText(target, answer);
+      if (!streamFinished) {
+        try {
+          const result = await this.#bot.sendText(target, visibleAnswer);
+          textReceipt = createDeliveryReceipt({
+            deliveryId: messageId,
+            presentation: `${this.#descriptor.key}-text`,
+            providerMessageIds: providerMessageIdsFor(result),
+          });
+        } catch (error) {
+          textDeliveryError = error;
+        }
+      }
+      // A failed final text must not discard an already registered result file.
+      // Settle the independent attachment path before surfacing the text error.
+      const delivery = await this.#deliverArtifacts(target, messageId, artifacts, textReceipt);
+      if (textDeliveryError && !delivery.userVisible) throw textDeliveryError;
       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 (stream) {

package/src/channels/shared/workspace-session.mjs

@@ -59,9 +59,23 @@ export async function askInWorkspaceSession({
         return { sessionId, session };
       });
       if (!binding) continue;
+      const artifacts = [];
+      const originalOnArtifact = typeof askOptions === 'object'
+        && typeof askOptions?.onArtifact === 'function'
+        ? askOptions.onArtifact
+        : null;
+      const artifactOptions = typeof askOptions === 'number'
+        ? { timeoutMs: askOptions }
+        : { ...askOptions };
+      artifactOptions.onArtifact = async (artifact) => {
+        artifacts.push(artifact);
+        await originalOnArtifact?.(artifact);
+      };
+      const answer = await binding.session.ask(content ?? text, artifactOptions);
       return {
         sessionId: binding.sessionId,
-        answer: await binding.session.ask(content ?? text, askOptions),
+        answer,
+        ...(artifacts.length > 0 ? { artifacts } : {}),
       };
     } catch (error) {
       if (error?.code !== WORKSPACE_SESSION_STALE) throw error;

package/src/channels/slack/manifest.mjs

@@ -18,6 +18,7 @@ oauth_config:
       - app_mentions:read
       - chat:write
       - files:read
+      - files:write
       - im:history
 settings:
   event_subscriptions:

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

@@ -5,6 +5,8 @@ const SLACK_FILE_HOST = 'files.slack.com';
 const LEGACY_SLACK_FILE_HOST = 'slack.com';
 const SLACK_FILE_PATH_PREFIX = '/files-pri/';
 const SLACK_FILE_HOSTS = Object.freeze([SLACK_FILE_HOST]);
+const SLACK_UPLOAD_PATH_PREFIX = '/upload/';
+const DEFAULT_FILE_UPLOAD_TIMEOUT_MS = 120_000;
 
 function cleanString(value) {
   return typeof value === 'string' && value.trim() ? value.trim() : null;
@@ -15,6 +17,47 @@ 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 (Number.isInteger(source?.status)) target.status = source.status;
+  return target;
+}
+
+function slackArtifactPreparationError(cause) {
+  let code = 'artifact-provider-failed';
+  let message = 'Slack file upload preparation failed';
+  if (cause?.code === 'slack-file_upload_size_restricted') {
+    code = 'artifact-too-large';
+    message = 'Slack rejected the result file because it is too large';
+  } else if (cause?.code === 'slack-missing-scope') {
+    code = 'artifact-permission-required';
+    message = 'Slack file delivery requires the files:write scope';
+  } else if (cause?.code?.startsWith?.('slack-')) {
+    code = 'artifact-provider-rejected';
+    message = 'Slack rejected file upload preparation';
+  }
+  const error = new Error(message, { cause });
+  error.code = code;
+  return preserveProviderMetadata(error, cause);
+}
+
+function uncertainSlackDelivery(cause) {
+  const error = new Error('Slack file completion result is uncertain', { cause });
+  error.code = 'artifact-delivery-uncertain';
+  return preserveProviderMetadata(error, cause);
+}
+
 function isRedirectStatus(status) {
   return Number.isInteger(status) && status >= 300 && status < 400;
 }
@@ -43,6 +86,17 @@ function secureSlackFileUrl(value) {
   return url;
 }
 
+function secureSlackUploadUrl(value) {
+  const url = new URL(value);
+  if (url.protocol !== 'https:' || url.username || url.password
+    || (url.port && url.port !== '443') || url.hostname !== SLACK_FILE_HOST
+    || !url.pathname.startsWith(SLACK_UPLOAD_PATH_PREFIX)) {
+    throw new Error('Slack returned an unsafe file upload URL');
+  }
+  url.hash = '';
+  return url;
+}
+
 function redirectUrl(response, source) {
   const location = response?.headers?.get?.('location');
   if (!location) return null;
@@ -111,6 +165,7 @@ function safeOutgoingText(value, { trim = true } = {}) {
 function apiFailure(method, payload, tokenKind) {
   const reason = cleanString(payload?.error) ?? 'unknown_error';
   const error = new Error(`Slack ${method} failed: ${reason.replaceAll('_', ' ')}`);
+  error.providerCode = reason;
   if (['invalid_auth', 'not_authed', 'token_revoked', 'account_inactive'].includes(reason)) {
     error.code = tokenKind === 'app' ? 'slack-invalid-app-token' : 'slack-invalid-bot-token';
   } else if (reason === 'missing_scope') {
@@ -141,8 +196,15 @@ export class SlackApi {
   #fetch;
   #baseUrl;
   #botScopes = null;
+  #fileUploadTimeoutMs;
 
-  constructor({ botToken, appToken, fetchImpl = fetch, baseUrl = DEFAULT_BASE_URL }) {
+  constructor({
+    botToken,
+    appToken,
+    fetchImpl = fetch,
+    baseUrl = DEFAULT_BASE_URL,
+    fileUploadTimeoutMs = DEFAULT_FILE_UPLOAD_TIMEOUT_MS,
+  }) {
     if (botToken !== undefined && !validSlackBotToken(botToken)) {
       throw new TypeError('Slack Bot Token is invalid');
     }
@@ -155,6 +217,7 @@ export class SlackApi {
     this.#appToken = appToken?.trim();
     this.#fetch = fetchImpl;
     this.#baseUrl = new URL(baseUrl);
+    this.#fileUploadTimeoutMs = positiveTimeout(fileUploadTimeoutMs, 'fileUploadTimeoutMs');
   }
 
   authTest(options = {}) {
@@ -239,6 +302,99 @@ export class SlackApi {
     });
   }
 
+  async uploadFile({ channelId, threadTs, file, signal }) {
+    if (!file || typeof file !== 'object'
+      || typeof file.fileName !== 'string' || !file.fileName
+      || !Buffer.isBuffer(file.bytes)) {
+      throw new TypeError('A Slack file is required');
+    }
+    if (signal?.aborted) throw abortReason(signal);
+    const uploadSignal = requestSignal(signal, this.#fileUploadTimeoutMs);
+    let ticket;
+    try {
+      ticket = await this.#request('files.getUploadURLExternal', {
+        tokenKind: 'bot',
+        signal: uploadSignal,
+        timeoutMs: this.#fileUploadTimeoutMs,
+        body: { filename: file.fileName, length: file.bytes.byteLength },
+      });
+    } catch (error) {
+      if (signal?.aborted) throw abortReason(signal);
+      throw slackArtifactPreparationError(error);
+    }
+    let fileId;
+    let uploadUrl;
+    try {
+      fileId = requiredString(ticket?.file_id, 'file id');
+      uploadUrl = secureSlackUploadUrl(ticket?.upload_url);
+    } catch (error) {
+      throw slackArtifactPreparationError(error);
+    }
+    let uploaded;
+    try {
+      uploaded = await this.#fetch(uploadUrl, {
+        method: 'POST',
+        headers: { 'content-type': file.mediaType ?? 'application/octet-stream' },
+        body: file.bytes,
+        signal: uploadSignal,
+        redirect: 'error',
+      });
+    } catch (error) {
+      if (signal?.aborted) throw abortReason(signal);
+      throw slackArtifactPreparationError(error);
+    }
+    if (!Number.isInteger(uploaded?.status)) {
+      throw slackArtifactPreparationError(new Error('Slack file upload returned an invalid response'));
+    }
+    if (uploaded.status !== 200) {
+      await cancelResponseBody(uploaded);
+      const error = new Error(`Slack file upload failed with HTTP ${uploaded.status}`);
+      error.status = uploaded.status;
+      if (uploaded.status === 413) {
+        error.code = 'artifact-too-large';
+      } else if (uploaded.status === 429) {
+        error.code = 'artifact-rate-limited';
+      } else {
+        error.code = 'artifact-provider-rejected';
+      }
+      throw error;
+    }
+    await cancelResponseBody(uploaded);
+
+    let completionBody;
+    try {
+      completionBody = {
+        files: [{ id: fileId, title: file.fileName }],
+        channel_id: slackId(channelId, 'channel id'),
+        ...(threadTs ? { thread_ts: requiredString(threadTs, 'thread timestamp') } : {}),
+      };
+    } catch (error) {
+      throw slackArtifactPreparationError(error);
+    }
+    if (uploadSignal.aborted) {
+      if (signal?.aborted) throw abortReason(signal);
+      throw slackArtifactPreparationError(uploadSignal.reason);
+    }
+    try {
+      const completed = await this.#request('files.completeUploadExternal', {
+        tokenKind: 'bot',
+        signal: uploadSignal,
+        timeoutMs: this.#fileUploadTimeoutMs,
+        retry: false,
+        body: completionBody,
+      });
+      if (!Array.isArray(completed?.files)
+        || !completed.files.some((entry) => cleanString(entry?.id) === fileId)) {
+        throw new Error('Slack file completion did not confirm the uploaded file');
+      }
+      return completed;
+    } catch (error) {
+      if (signal?.aborted) throw abortReason(signal);
+      if (error?.code === 'slack-missing-scope') throw slackArtifactPreparationError(error);
+      throw uncertainSlackDelivery(error);
+    }
+  }
+
   async downloadFile({ url, signal, maxBytes }) {
     if (!this.#botToken) throw new TypeError('Slack bot token is required for file download');
     const target = secureSlackFileUrl(url);
@@ -276,18 +432,21 @@ export class SlackApi {
   }) {
     const token = tokenKind === 'app' ? this.#appToken : this.#botToken;
     if (!token) throw new TypeError(`Slack ${tokenKind} token is required for ${method}`);
+    const formEncoded = method === 'files.getUploadURLExternal';
     let response;
     try {
       response = await this.#fetch(new URL(method, this.#baseUrl), {
         method: 'POST',
         headers: {
           authorization: `Bearer ${token}`,
-          'content-type': body === undefined
+          'content-type': body === undefined || formEncoded
             ? 'application/x-www-form-urlencoded;charset=utf-8'
             : 'application/json;charset=utf-8',
           'user-agent': 'DeepSeek-Harness-dsh-im (https://github.com/xmanrui/dsh-im, 0.2.2)',
         },
-        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+        ...(body === undefined ? {} : {
+          body: formEncoded ? new URLSearchParams(body).toString() : JSON.stringify(body),
+        }),
         signal: requestSignal(signal, timeoutMs),
         redirect: 'error',
       });
@@ -312,7 +471,11 @@ export class SlackApi {
       await delay(Math.min(10_000, Math.max(100, seconds * 1_000)), signal);
       return this.#request(method, { tokenKind, body, signal, timeoutMs, retry: false });
     }
-    if (!response.ok || payload?.ok !== true) throw apiFailure(method, payload, tokenKind);
+    if (!response.ok || payload?.ok !== true) {
+      const error = apiFailure(method, payload, tokenKind);
+      error.status = response.status;
+      throw error;
+    }
     return payload;
   }
 }