@xmanrui/dsh-im 4.38.0 → 4.38.2

package/src/channels/shared/markdown-chunks.mjs

@@ -0,0 +1,338 @@
+// Structure-aware Markdown chunks reused by outbound channel renderers.
+const DEFAULT_CHUNK_LIMIT = 4_500;
+const CODE_FENCE_OPEN = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+
+function safeSliceIndex(value, limit) {
+  let index = Math.min(limit, value.length);
+  const before = value.charCodeAt(index - 1);
+  const after = value.charCodeAt(index);
+  if (before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF) {
+    index -= 1;
+  }
+  return Math.max(1, index);
+}
+
+function openingFence(line) {
+  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+  const match = CODE_FENCE_OPEN.exec(normalized);
+  if (!match) return null;
+  // CommonMark forbids backticks in the info string of a backtick fence.
+  if (match[2][0] === '`' && match[3].includes('`')) return null;
+  return { delimiter: match[2], info: match[3], indent: match[1].length };
+}
+
+function closesFence(line, opening) {
+  const match = /^ {0,3}(`{3,}|~{3,})[ \t]*$/.exec(line);
+  return Boolean(match
+    && match[1][0] === opening.delimiter[0]
+    && match[1].length >= opening.delimiter.length);
+}
+
+function longestLeadingRun(text, character) {
+  let longest = 0;
+  for (const line of text.split('\n')) {
+    let offset = 0;
+    while (offset < 3 && line[offset] === ' ') offset += 1;
+    let length = 0;
+    while (line[offset + length] === character) length += 1;
+    longest = Math.max(longest, length);
+  }
+  return longest;
+}
+
+function safeCodeFence(text, info) {
+  const backticks = '`'.repeat(Math.max(3, longestLeadingRun(text, '`') + 1));
+  const tildes = '~'.repeat(Math.max(3, longestLeadingRun(text, '~') + 1));
+  if (info.includes('`')) return tildes;
+  return backticks.length <= tildes.length ? backticks : tildes;
+}
+
+function removeFenceIndent(line, indent) {
+  let index = 0;
+  let column = 0;
+  let remaining = indent;
+  while (remaining > 0 && index < line.length) {
+    if (line[index] === ' ') {
+      index += 1;
+      column += 1;
+      remaining -= 1;
+      continue;
+    }
+    if (line[index] === '\t') {
+      const width = 4 - (column % 4);
+      if (width <= remaining) {
+        index += 1;
+        column += width;
+        remaining -= width;
+        continue;
+      }
+      return `${' '.repeat(width - remaining)}${line.slice(index + 1)}`;
+    }
+    break;
+  }
+  return line.slice(index);
+}
+
+function normalizeFencedContent(lines, indent) {
+  return indent === 0 ? lines : lines.map((line) => removeFenceIndent(line, indent));
+}
+
+function splitRawText(text, limit) {
+  if (text.length <= limit) return [text];
+  const parts = [];
+  let remaining = text;
+  while (remaining.length > limit) {
+    let index = safeSliceIndex(remaining, limit);
+    const newline = remaining.lastIndexOf('\n', index - 1);
+    if (newline >= 0) index = newline + 1;
+    parts.push(remaining.slice(0, index));
+    remaining = remaining.slice(index);
+  }
+  if (remaining || parts.length === 0) parts.push(remaining);
+  return parts;
+}
+
+function splitAsFencedCode(text, info, limit) {
+  if (limit < 8) return splitRawText(text, limit).map((part) => ({
+    markdown: part,
+    plain: part,
+  }));
+  const delimiter = safeCodeFence(text, info);
+  let opening = `${delimiter}${info}`;
+  if (opening.length + delimiter.length + 2 >= limit) opening = delimiter;
+  const payloadLimit = limit - opening.length - delimiter.length - 2;
+  if (payloadLimit < 1) return splitRawText(text, limit).map((part) => ({
+    markdown: part,
+    plain: part,
+  }));
+  return splitRawText(text, payloadLimit).map((part) => (
+    {
+      markdown: `${opening}\n${part}${part.endsWith('\n') ? '' : '\n'}${delimiter}`,
+      plain: part,
+    }
+  ));
+}
+
+function hasClosingBacktickRun(text, start, length) {
+  for (let index = start; index < text.length;) {
+    if (text[index] !== '`') {
+      index += 1;
+      continue;
+    }
+    let end = index + 1;
+    while (text[end] === '`') end += 1;
+    if (end - index === length) return true;
+    index = end;
+  }
+  return false;
+}
+
+function gfmTableCells(line) {
+  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+  if (normalized.startsWith('    ') || normalized.startsWith('\t')) return null;
+  const text = normalized.trim();
+  if (!text) return null;
+
+  const cells = [];
+  let cell = '';
+  let separators = 0;
+  let codeRun = 0;
+  for (let index = 0; index < text.length;) {
+    const character = text[index];
+    if (character === '\\' && index + 1 < text.length) {
+      cell += text.slice(index, index + 2);
+      index += 2;
+      continue;
+    }
+    if (character === '`') {
+      let end = index + 1;
+      while (text[end] === '`') end += 1;
+      const length = end - index;
+      if (codeRun === length) {
+        codeRun = 0;
+      } else if (codeRun === 0 && hasClosingBacktickRun(text, end, length)) {
+        codeRun = length;
+      }
+      cell += text.slice(index, end);
+      index = end;
+      continue;
+    }
+    if (character === '|' && codeRun === 0) {
+      cells.push(cell);
+      cell = '';
+      separators += 1;
+      index += 1;
+      continue;
+    }
+    cell += character;
+    index += 1;
+  }
+  if (separators === 0) return null;
+  cells.push(cell);
+  if (cells[0].trim() === '') cells.shift();
+  if (cells.at(-1)?.trim() === '') cells.pop();
+  return cells.length > 0 ? cells : null;
+}
+
+function gfmTableStart(lines, index) {
+  const headerCells = gfmTableCells(lines[index]);
+  const separatorCells = gfmTableCells(lines[index + 1] ?? '');
+  if (!headerCells || !separatorCells || headerCells.length !== separatorCells.length) return null;
+  if (!separatorCells.every((cell) => /^\s*:?-+:?\s*$/.test(cell))) return null;
+  return { headerCells };
+}
+
+function supportedTableBodyCells(line) {
+  const normalized = line.endsWith('\r') ? line.slice(0, -1) : line;
+  const content = normalized.replace(/^ {0,3}/, '');
+  if (openingFence(normalized)
+    || /^(?:#{1,6}(?:[ \t]+|$)|>|(?:[-+*]|\d{1,9}[.)])[ \t]+)/.test(content)) {
+    return null;
+  }
+  return gfmTableCells(normalized);
+}
+
+function splitOversizedTable(lines, limit) {
+  const source = lines.join('\n');
+  if (lines.length < 2 || !gfmTableStart(lines, 0)) {
+    return splitAsFencedCode(source, 'text', limit);
+  }
+  const prefix = `${lines[0]}\n${lines[1]}`;
+  const rows = lines.slice(2);
+  if (prefix.length > limit
+    || rows.some((row) => `${prefix}\n${row}`.length > limit)) {
+    return splitAsFencedCode(source, 'text', limit);
+  }
+  const chunks = [];
+  let current = prefix;
+  let currentRows = [];
+  for (const row of rows) {
+    const candidate = `${current}\n${row}`;
+    if (candidate.length > limit) {
+      chunks.push({
+        markdown: current,
+        plain: chunks.length === 0 ? current : currentRows.join('\n'),
+      });
+      current = `${prefix}\n${row}`;
+      currentRows = [row];
+    } else {
+      current = candidate;
+      currentRows.push(row);
+    }
+  }
+  chunks.push({
+    markdown: current,
+    plain: chunks.length === 0 ? current : currentRows.join('\n'),
+  });
+  return chunks;
+}
+
+/**
+ * 按换行边界切分 Markdown 文本：
+ * - 可容纳的代码块和可识别的 GFM pipe table 保持完整；
+ * - 超长代码块会补齐围栏，超长表格会为每段重复表头；
+ * - 超长行在 limit 处硬切，避免单行超限无法投递。
+ */
+export function chunkMarkdownParts(text, limit = DEFAULT_CHUNK_LIMIT) {
+  const value = typeof text === 'string' ? text : '';
+  const bound = Number.isInteger(limit) && limit > 0 ? limit : DEFAULT_CHUNK_LIMIT;
+  if (value.length <= bound) return value ? [{ markdown: value, plain: value }] : [];
+
+  // Once splitting is required, normalize line endings so a chunk never ends
+  // with a dangling CR whose paired LF moved to the next QQ message.
+  const lines = value.replace(/\r\n?/g, '\n').split('\n');
+  const chunks = [];
+  let current = null;
+
+  const flushCurrent = () => {
+    if (current === null) return;
+    if (current.length > 0) chunks.push({ markdown: current, plain: current });
+    current = null;
+  };
+
+  const appendBlock = (block) => {
+    if (block.length <= bound) {
+      if (current === null) {
+        current = block;
+        return;
+      }
+      const candidate = `${current}\n${block}`;
+      if (candidate.length > bound) {
+        if (current.length > 0) chunks.push({ markdown: current, plain: current });
+        current = block;
+      } else {
+        current = candidate;
+      }
+      return;
+    }
+    // 超大块：收束当前块后按 bound 硬切，保证每块可投递。
+    flushCurrent();
+    let remaining = block;
+    while (remaining.length > bound) {
+      const index = safeSliceIndex(remaining, bound);
+      const part = remaining.slice(0, index);
+      chunks.push({ markdown: part, plain: part });
+      remaining = remaining.slice(index);
+    }
+    current = remaining;
+  };
+
+  const appendLine = (line) => {
+    let remaining = line;
+    // 超长行先硬切，保证每块不超过 bound。
+    while (remaining.length > bound) {
+      flushCurrent();
+      const index = safeSliceIndex(remaining, bound);
+      const part = remaining.slice(0, index);
+      chunks.push({ markdown: part, plain: part });
+      remaining = remaining.slice(index);
+    }
+    appendBlock(remaining);
+  };
+
+  for (let index = 0; index < lines.length;) {
+    const fence = openingFence(lines[index]);
+    if (fence) {
+      flushCurrent();
+      let end = index + 1;
+      while (end < lines.length && !closesFence(lines[end], fence)) end += 1;
+      const hasClosingFence = end < lines.length;
+      const blockLines = lines.slice(index, hasClosingFence ? end + 1 : lines.length);
+      const block = blockLines.join('\n');
+      if (block.length <= bound) {
+        appendBlock(block);
+      } else {
+        const contentLines = blockLines.slice(1, hasClosingFence ? -1 : undefined);
+        const content = normalizeFencedContent(contentLines, fence.indent).join('\n');
+        chunks.push(...splitAsFencedCode(content, fence.info, bound));
+      }
+      index = hasClosingFence ? end + 1 : lines.length;
+      continue;
+    }
+
+    if (gfmTableStart(lines, index)) {
+      let end = index + 2;
+      while (end < lines.length && supportedTableBodyCells(lines[end])) end += 1;
+      const tableLines = lines.slice(index, end);
+      const table = tableLines.join('\n');
+      if (table.length <= bound) {
+        appendBlock(table);
+      } else {
+        flushCurrent();
+        chunks.push(...splitOversizedTable(tableLines, bound));
+      }
+      index = end;
+      continue;
+    }
+
+    appendLine(lines[index]);
+    index += 1;
+  }
+
+  flushCurrent();
+  return chunks.filter(({ markdown, plain }) => markdown.length > 0 || plain.length > 0);
+}
+
+export function chunkMarkdownText(text, limit = DEFAULT_CHUNK_LIMIT) {
+  return chunkMarkdownParts(text, limit).map(({ markdown }) => markdown);
+}

package/src/channels/shared/message-failure.mjs

@@ -1,4 +1,4 @@
-import { connectionHint, extractConnectionEvidence } from './connection-error.mjs';
+import { connectionHint, extractConnectionEvidence, messageDiagnosticError, runtimeDiagnosticDetails } from './connection-error.mjs';
 import { diagnosticFields } from './diagnostic-details.mjs';
 import { randomUUID } from 'node:crypto';
 
@@ -26,6 +26,8 @@ const PROVIDER_FAILURES = Object.freeze({
 });
 
 const FAILURE_MESSAGES = Object.freeze({
+  HARNESS_INTERACTION_TIMEOUT:
+    '与 DSH 的交互通道在 30 秒内未就绪，本条消息尚未提交执行。请稍后重试。',
   HARNESS_CONNECT:
     '无法连接处理服务，消息尚未提交。请确认 DeepSeek Harness 正在运行后重试。',
   HARNESS_TIMEOUT:
@@ -107,18 +109,23 @@ function providerFailureCode(error) {
   return PROVIDER_FAILURES[value.trim().toUpperCase()] ?? null;
 }
 
-function failureCode(error) {
+function failureCode(error, details) {
   const code = typeof error?.code === 'string' ? error.code : '';
   const providerCode = providerFailureCode(error);
   if (providerCode) return providerCode;
+  if (code === 'harness-interaction-timeout') return 'HARNESS_INTERACTION_TIMEOUT';
+
+  const uncertain = details.submissionState === undefined
+    ? ['session.prompt', 'session.history'].includes(error?.method)
+    : details.submissionState !== 'not-submitted';
 
   if (code === 'harness-connect-failed') {
-    return ['session.prompt', 'session.history'].includes(error?.method)
+    return uncertain
       ? 'HARNESS_RESULT_UNCERTAIN'
       : 'HARNESS_CONNECT';
   }
   if (code === 'harness-timeout') {
-    return ['session.prompt', 'session.history'].includes(error?.method)
+    return uncertain
       ? 'HARNESS_RESULT_UNCERTAIN'
       : 'HARNESS_TIMEOUT';
   }
@@ -128,7 +135,7 @@ function failureCode(error) {
     'harness-loopback-forbidden', 'harness-host-untrusted',
     'harness-request-forbidden',
   ].includes(code)) return 'HARNESS_ACCESS';
-  if (['harness-api-not-found', 'harness-response-invalid'].includes(code)) {
+  if (['harness-api-not-found', 'harness-response-invalid', 'gateway/input-invalid'].includes(code)) {
     return 'HARNESS_PROTOCOL';
   }
   if (code === 'harness-turn-failed') return 'INTERNAL_UNKNOWN';
@@ -205,25 +212,38 @@ export function classifyMessageFailure(error, {
   at = Date.now(),
 } = {}) {
   const safeReason = safeFailureReason(reason);
-  const classifiedCode = failureCode(error);
+  const details = extractConnectionEvidence(error).details;
+  const classifiedCode = failureCode(error, details);
   const businessCode = classifiedCode === 'INTERNAL_UNKNOWN'
     && safeReason
     && typeof userMessage === 'string'
     && userMessage.trim()
     ? 'INPUT_INVALID'
     : classifiedCode;
-  const details = extractConnectionEvidence(error).details;
   const code = businessCode === 'INTERNAL_UNKNOWN'
     ? transportFailureCode(error, details)
     : businessCode;
   if (code === 'REQUEST_TIMEOUT' || code === 'NETWORK_ERROR') details.hint = connectionHint(details);
+  if (details.stage || details.submissionState) Object.assign(details, runtimeDiagnosticDetails());
+  let message = FAILURE_MESSAGES[code];
+  if (['INTERNAL_UNKNOWN', 'REQUEST_TIMEOUT', 'NETWORK_ERROR'].includes(code)) {
+    if (details.submissionState === 'not-submitted') {
+      message = code === 'REQUEST_TIMEOUT'
+        ? '消息提交前的操作超时，本条消息尚未提交执行。请稍后重试。'
+        : code === 'NETWORK_ERROR'
+          ? '消息提交前的网络请求失败，本条消息尚未提交执行。请检查连接后重试。'
+          : '消息在提交前处理失败，尚未提交执行。请重试；若持续发生，请将参考号提供给管理员。';
+    } else if (details.submissionState) {
+      message = '消息已尝试提交，但任务结果尚未确认。请先到 DSH 查看状态，不要立即重复提交；若持续发生，请将参考号提供给管理员。';
+    }
+  }
   return Object.freeze({
-    ...(code === 'INTERNAL_UNKNOWN' || details.reason !== 'unknown' || details.httpStatus || details.providerCode || details.method ? { details } : {}),
+    ...(code === 'INTERNAL_UNKNOWN' || details.reason !== 'unknown' || details.httpStatus || details.providerCode || details.method || details.stage || details.submissionState ? { details } : {}),
     code,
     reason: safeReason ?? safeFailureReason(error?.code) ?? code,
     message: typeof userMessage === 'string' && userMessage.trim()
       ? userMessage.trim()
-      : t(FAILURE_MESSAGES[code]) + (code === 'SESSION_ARCHIVED' && error?.promptAccepted === true
+      : t(message) + (code === 'SESSION_ARCHIVED' && error?.promptAccepted === true
         ? `\n${t('本条消息可能仍在会话队列中，请先到 DSH 查看状态，避免重复提交。')}` : ''),
     referenceId: safeReferenceId(referenceId),
     at: Number.isFinite(at) ? at : Date.now(),
@@ -237,7 +257,7 @@ export function messageFailureText(failure) {
 export function messageFailureDiagnostic(error, failure) {
   const evidence = extractConnectionEvidence(error);
   return { code: failure.code, reason: failure.reason, referenceId: failure.referenceId,
-    details: evidence.details, errors: evidence.errors };
+    details: failure.details ?? evidence.details, errors: evidence.errors, ...evidence.correlation };
 }
 
 export function setLastMessageFailure(status, error, options) {
@@ -262,7 +282,7 @@ export function channelDeliveryFailure(error, { uncertain = true } = {}) {
         ? 'channel-delivery-uncertain'
         : 'channel-delivery-failed';
   if (Number.isInteger(status)) wrapped.status = status;
-  return wrapped;
+  return messageDiagnosticError(wrapped, { stage: 'message.send' });
 }
 
 export function publicMessageFailure(value) {

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

@@ -649,8 +649,11 @@ export class TextHarnessBridge {
     });
   }
 
-  sendProactiveText(target, text, { signal } = {}) {
+  sendProactiveText(target, text, { signal, format = 'plain' } = {}) {
     signal?.throwIfAborted();
+    if (format === 'markdown' && typeof this.#bot.sendDelivery === 'function') {
+      return this.#bot.sendDelivery(target, createTextDeliveryBlock(text, format));
+    }
     return this.#bot.sendText(target, text);
   }
 

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

@@ -1,5 +1,6 @@
 import { withSessionBindingLock } from './session-binding-lock.mjs';
 import { initialSessionTitle } from './session-title.mjs';
+import { messageDiagnosticError } from './connection-error.mjs';
 
 export const WORKSPACE_SESSION_STALE = 'workspace-session-stale';
 
@@ -114,16 +115,19 @@ export async function askInWorkspaceSession({
     ?? (typeof askOptions === 'object' ? askOptions?.signal : undefined);
   const renameOptions = renameSignal ? { signal: renameSignal } : undefined;
   while (true) {
+    const diagnostic = { stage: 'session.prepare', submissionState: 'not-submitted' };
     try {
       const binding = await withSessionBindingLock(state, key, async () => {
         await awaitPendingConversationSwitch(harness, key);
         let sessionId = state.sessionFor(key);
+        diagnostic.sessionId = sessionId;
         let session = sessionId ? workspaceSession(harness, sessionId, key) : null;
         if (!session || !(await sessionExists(session, existsOptions))) {
           sessionId = await createSession(harness, {
             conversationKey: key,
             ...(createOptions ?? {}),
           });
+          diagnostic.sessionId = sessionId;
           if (await state.setSession(key, sessionId) === false) return null;
           // Binding committed: capture the conversation's effective-workspace
           // generation together with the session, so the prompt below is fenced
@@ -150,6 +154,8 @@ export async function askInWorkspaceSession({
         return { sessionId, session };
       });
       if (!binding) continue;
+      diagnostic.sessionId = binding.sessionId;
+      diagnostic.stage = 'prompt.prepare';
       const artifacts = [];
       const originalOnArtifact = typeof askOptions === 'object'
         && typeof askOptions?.onArtifact === 'function'
@@ -172,6 +178,9 @@ export async function askInWorkspaceSession({
         ? await prepareContent({ sessionId: binding.sessionId, content, text })
         : content ?? text;
       try {
+        // An alternate Harness adapter may not supply finer ask() diagnostics.
+        diagnostic.stage = 'operation';
+        diagnostic.submissionState = 'unknown';
         answer = await binding.session.ask(prompt, artifactOptions);
       } catch (error) {
         if (error?.code === 'harness-reply-timeout' && deferredDelivery) {
@@ -190,7 +199,7 @@ export async function askInWorkspaceSession({
         ...(artifacts.length > 0 ? { artifacts } : {}),
       };
     } catch (error) {
-      if (error?.code !== WORKSPACE_SESSION_STALE) throw error;
+      if (error?.code !== WORKSPACE_SESSION_STALE) throw messageDiagnosticError(error, diagnostic);
     }
   }
 }

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

@@ -271,13 +271,14 @@ export class SlackApi {
       : null;
   }
 
-  postMessage({ channelId, text, threadTs, signal }) {
+  postMessage({ channelId, text, threadTs, signal, format = 'plain' }) {
     return this.#request('chat.postMessage', {
       tokenKind: 'bot',
       signal,
       body: {
         channel: slackId(channelId, 'channel id'),
         text: safeOutgoingText(text),
+        ...(format === 'markdown' ? { blocks: [{ type: 'markdown', text: safeOutgoingText(text) }] } : {}),
         ...(threadTs ? { thread_ts: cleanString(threadTs) } : {}),
         mrkdwn: true,
         link_names: false,

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

@@ -1,5 +1,7 @@
 import { extractConnectionEvidence, createConnectionDiagnostics, atConnectionStage } from '../shared/connection-error.mjs';
 import { splitMessageText } from '../shared/editable-message-stream.mjs';
+import { chunkMarkdownParts } from '../shared/markdown-chunks.mjs';
+import { createTextDeliveryBlock } from '../shared/semantic/delivery.mjs';
 import { t } from '../shared/i18n.mjs';
 import { SlackApi } from './slack-api.mjs';
 import { createSlackBridgeStatus, SlackHarnessBridge } from './slack-bridge.mjs';
@@ -350,6 +352,34 @@ export class SlackBotClient {
     return { providerMessageIds };
   }
 
+  async sendDelivery(target, value) {
+    const block = createTextDeliveryBlock(value);
+    if (block.format === 'plain') return this.sendText(target, block.text);
+    const providerMessageIds = [];
+    // Standard Markdown blocks have a 12,000-character payload limit.
+    for (const chunk of chunkMarkdownParts(block.text, SLACK_STREAM_CHUNK_LIMIT)) {
+      this.#signal?.throwIfAborted();
+      try {
+        const result = await this.#api.postMessage({
+          channelId: target.channelId, threadTs: target.threadTs,
+          text: chunk.markdown, format: 'markdown', signal: this.#signal,
+        });
+        if (typeof result?.ts === 'string' && result.ts) providerMessageIds.push(result.ts);
+      } catch (error) {
+        // Retry only a definite formatting rejection, never an ambiguous send.
+        if (this.#signal?.aborted || Number(error?.status) >= 500
+          || !['invalid_blocks', 'invalid_blocks_format', 'invalid_markdown']
+            .includes(error?.providerCode)) throw error;
+        this.#logger?.warn?.('[dsh-im:slack] Markdown rejected; sending this chunk as text');
+        if (chunk.plain) {
+          const result = await this.sendText(target, chunk.plain);
+          providerMessageIds.push(...result.providerMessageIds);
+        }
+      }
+    }
+    return { providerMessageIds };
+  }
+
   async addReaction(target, emoji, { signal } = {}) {
     const reactionKey = String(emoji ?? '').trim();
     await this.#api.addReaction({

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

@@ -761,6 +761,7 @@ export class TelegramBotClient {
     try {
       chunks = splitTelegramRichMarkdown(block.text);
     } catch {
+      this.#logger.warn?.('[dsh-im:telegram] Rich Markdown could not be prepared; sending plain text');
       return this.#sendPlain(target, block.text);
     }
     const providerMessageIds = [];