codeksei 0.1.0 → 0.1.1

package/src/adapters/channel/weixin/legacy.js

@@ -1,567 +1,580 @@
-const crypto = require("crypto");
-const { listWeixinAccounts } = require("./account-store");
-const { resolveSelectedAccount } = require("./account-store");
-const { loadPersistedContextTokens, persistContextToken } = require("./context-token-store");
-const { runLegacyLoginFlow } = require("./login-legacy");
-const { getConfig, getUpdates, sendMessage, sendTyping } = require("./api");
-const { sendWeixinMediaFile } = require("./media-send");
-const { normalizeWeixinIncomingMessage } = require("./message-utils");
-const { loadSyncBuffer, saveSyncBuffer } = require("./sync-buffer-store");
-
-const LONG_POLL_TIMEOUT_MS = 35_000;
-const SEND_MESSAGE_CHUNK_INTERVAL_MS = 350;
-const WEIXIN_SEND_CHUNK_LIMIT = 80;
-const MAX_WEIXIN_CHUNK = 3800;
-const WEIXIN_MAX_DELIVERY_MESSAGES = 10;
-const SEND_RETRY_DELAYS_MS = [900, 1800];
-
-function createLegacyWeixinChannelAdapter(config) {
-  let selectedAccount = null;
-  let contextTokenCache = null;
-
-  function ensureAccount() {
-    if (!selectedAccount) {
-      selectedAccount = resolveSelectedAccount(config);
-      contextTokenCache = loadPersistedContextTokens(config, selectedAccount.accountId);
-    }
-    return selectedAccount;
-  }
-
-  function ensureContextTokenCache() {
-    if (!contextTokenCache) {
-      const account = ensureAccount();
-      contextTokenCache = loadPersistedContextTokens(config, account.accountId);
-    }
-    return contextTokenCache;
-  }
-
-  function rememberContextToken(userId, contextToken) {
-    const account = ensureAccount();
-    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
-    const normalizedToken = typeof contextToken === "string" ? contextToken.trim() : "";
-    if (!normalizedUserId || !normalizedToken) {
-      return "";
-    }
-    contextTokenCache = persistContextToken(config, account.accountId, normalizedUserId, normalizedToken);
-    return normalizedToken;
-  }
-
-  function resolveContextToken(userId, explicitToken = "") {
-    const normalizedExplicitToken = typeof explicitToken === "string" ? explicitToken.trim() : "";
-    if (normalizedExplicitToken) {
-      return normalizedExplicitToken;
-    }
-    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
-    if (!normalizedUserId) {
-      return "";
-    }
-    return ensureContextTokenCache()[normalizedUserId] || "";
-  }
-
-  return {
-    describe() {
-      return {
-        id: "weixin",
-        variant: "legacy",
-        kind: "channel",
-        stateDir: config.stateDir,
-        baseUrl: config.weixinBaseUrl,
-        accountsDir: config.accountsDir,
-        syncBufferDir: config.syncBufferDir,
-      };
-    },
-    async login() {
-      await runLegacyLoginFlow(config);
-    },
-    printAccounts() {
-      const accounts = listWeixinAccounts(config);
-      if (!accounts.length) {
-        console.log("当前没有已保存的微信账号。先执行 `npm run login`。");
-        return;
-      }
-      console.log("已保存账号：");
-      for (const account of accounts) {
-        console.log(`- ${account.accountId}`);
-        console.log(`  userId: ${account.userId || "(unknown)"}`);
-        console.log(`  baseUrl: ${account.baseUrl || config.weixinBaseUrl}`);
-        if (account.routeTag) {
-          console.log(`  routeTag: ${account.routeTag}`);
-        }
-        console.log(`  savedAt: ${account.savedAt || "(unknown)"}`);
-      }
-    },
-    resolveAccount() {
-      return ensureAccount();
-    },
-    getKnownContextTokens() {
-      return { ...ensureContextTokenCache() };
-    },
-    loadSyncBuffer() {
-      const account = ensureAccount();
-      return loadSyncBuffer(config, account.accountId);
-    },
-    saveSyncBuffer(buffer) {
-      const account = ensureAccount();
-      saveSyncBuffer(config, account.accountId, buffer);
-    },
-    rememberContextToken,
-    async getUpdates({ syncBuffer = "", timeoutMs = LONG_POLL_TIMEOUT_MS } = {}) {
-      const account = ensureAccount();
-      const response = await getUpdates({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        get_updates_buf: syncBuffer,
-        timeoutMs,
-      });
-      if (typeof response?.get_updates_buf === "string" && response.get_updates_buf.trim()) {
-        this.saveSyncBuffer(response.get_updates_buf.trim());
-      }
-      const messages = Array.isArray(response?.msgs) ? response.msgs : [];
-      for (const message of messages) {
-        const userId = typeof message?.from_user_id === "string" ? message.from_user_id.trim() : "";
-        const contextToken = typeof message?.context_token === "string" ? message.context_token.trim() : "";
-        if (userId && contextToken) {
-          rememberContextToken(userId, contextToken);
-        }
-      }
-      return response;
-    },
-    normalizeIncomingMessage(message) {
-      const account = ensureAccount();
-      return normalizeWeixinIncomingMessage(message, config, account.accountId);
-    },
-    async sendText({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
-      const account = ensureAccount();
-      const resolvedToken = resolveContextToken(userId, contextToken);
-      if (!resolvedToken) {
-        throw new Error(`缺少 context_token，无法回复用户 ${userId}`);
-      }
-      const content = String(text || "");
-      const sendChunks = preserveBlock
-        ? splitUtf8(compactPlainTextForWeixin(content) || "已完成。", MAX_WEIXIN_CHUNK)
-        : packChunksForWeixinDelivery(
-          chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT).length
-            ? chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT)
-            : ["已完成。"],
-          WEIXIN_MAX_DELIVERY_MESSAGES,
-          MAX_WEIXIN_CHUNK
-        );
-      const traceContext = buildWeixinTraceContext(trace, {
-        enabled: config.weixinDeliveryTrace,
-        origin: "adapter.sendText",
-        variant: "legacy",
-        preserveBlock,
-        chunkTotal: sendChunks.length,
-      });
-      for (let index = 0; index < sendChunks.length; index += 1) {
-        const compactChunk = compactPlainTextForWeixin(sendChunks[index]) || "已完成。";
-        const clientId = crypto.randomUUID();
-        await sendLegacyTextChunk({
-          baseUrl: account.baseUrl,
-          token: account.token,
-          toUserId: userId,
-          text: compactChunk,
-          contextToken: resolvedToken,
-          clientId,
-          trace: {
-            ...traceContext,
-            chunkIndex: index + 1,
-            chars: compactChunk.length,
-            textHash: hashTraceText(compactChunk),
-            clientId,
-          },
-        });
-        if (index < sendChunks.length - 1) {
-          await sleep(SEND_MESSAGE_CHUNK_INTERVAL_MS);
-        }
-      }
-    },
-    async sendTyping({ userId, status = 1, contextToken = "" }) {
-      const account = ensureAccount();
-      const resolvedToken = resolveContextToken(userId, contextToken);
-      if (!resolvedToken) {
-        return;
-      }
-      const configResponse = await getConfig({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        ilinkUserId: userId,
-        contextToken: resolvedToken,
-      }).catch(() => null);
-      const typingTicket = typeof configResponse?.typing_ticket === "string"
-        ? configResponse.typing_ticket.trim()
-        : "";
-      if (!typingTicket) {
-        return;
-      }
-      await sendTyping({
-        baseUrl: account.baseUrl,
-        token: account.token,
-        body: {
-          ilink_user_id: userId,
-          typing_ticket: typingTicket,
-          status,
-        },
-      });
-    },
-    async sendFile({ userId, filePath, contextToken = "" }) {
-      const account = ensureAccount();
-      const resolvedToken = resolveContextToken(userId, contextToken);
-      if (!resolvedToken) {
-        throw new Error(`缺少 context_token，无法发送文件给用户 ${userId}`);
-      }
-      return sendWeixinMediaFile({
-        filePath,
-        to: userId,
-        contextToken: resolvedToken,
-        baseUrl: account.baseUrl,
-        token: account.token,
-        cdnBaseUrl: config.weixinCdnBaseUrl,
-      });
-    },
-  };
-}
-
-function splitUtf8(text, maxRunes) {
-  const runes = Array.from(String(text || ""));
-  if (!runes.length || runes.length <= maxRunes) {
-    return [String(text || "")];
-  }
-  const chunks = [];
-  while (runes.length) {
-    chunks.push(runes.splice(0, maxRunes).join(""));
-  }
-  return chunks;
-}
-
-function compactPlainTextForWeixin(text) {
-  const normalized = String(text || "").replace(/\r\n/g, "\n");
-  return trimOuterBlankLines(normalized.replace(/\n\s*\n+/g, "\n"));
-}
-
-function chunkReplyText(text, limit = 3500) {
-  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
-  if (!normalized.trim()) {
-    return [];
-  }
-
-  const chunks = [];
-  let remaining = normalized;
-  while (remaining.length > limit) {
-    const candidate = remaining.slice(0, limit);
-    const splitIndex = Math.max(
-      candidate.lastIndexOf("\n\n"),
-      candidate.lastIndexOf("\n"),
-      candidate.lastIndexOf("。"),
-      candidate.lastIndexOf(". "),
-      candidate.lastIndexOf(" ")
-    );
-    const cut = splitIndex > limit * 0.4 ? splitIndex + (candidate[splitIndex] === "\n" ? 0 : 1) : limit;
-    const chunk = trimOuterBlankLines(remaining.slice(0, cut));
-    if (chunk.trim()) {
-      chunks.push(chunk);
-    }
-    remaining = trimOuterBlankLines(remaining.slice(cut));
-  }
-  if (remaining) {
-    chunks.push(remaining);
-  }
-  return chunks.filter(Boolean);
-}
-
-function chunkReplyTextForWeixin(text, limit = 80) {
-  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
-  if (!normalized.trim()) {
-    return [];
-  }
-
-  const boundaries = collectStreamingBoundaries(normalized);
-  if (!boundaries.length) {
-    return chunkReplyText(normalized, limit);
-  }
-
-  const units = [];
-  let start = 0;
-  for (const boundary of boundaries) {
-    if (boundary <= start) {
-      continue;
-    }
-    const unit = trimOuterBlankLines(normalized.slice(start, boundary));
-    if (unit) {
-      units.push(unit);
-    }
-    start = boundary;
-  }
-
-  const tail = trimOuterBlankLines(normalized.slice(start));
-  if (tail) {
-    units.push(tail);
-  }
-
-  if (!units.length) {
-    return chunkReplyText(normalized, limit);
-  }
-
-  const chunks = [];
-  for (const unit of units) {
-    if (unit.length <= limit) {
-      chunks.push(unit);
-      continue;
-    }
-    chunks.push(...chunkReplyText(unit, limit));
-  }
-  return chunks.filter(Boolean);
-}
-
-function packChunksForWeixinDelivery(chunks, maxMessages = 10, maxChunkChars = 3800) {
-  const normalizedChunks = Array.isArray(chunks)
-    ? chunks.map((chunk) => compactPlainTextForWeixin(chunk)).filter(Boolean)
-    : [];
-  if (!normalizedChunks.length || normalizedChunks.length <= maxMessages) {
-    return normalizedChunks;
-  }
-
-  const packed = normalizedChunks.slice(0, Math.max(0, maxMessages - 1));
-  const tailChunks = normalizedChunks.slice(Math.max(0, maxMessages - 1));
-  if (!tailChunks.length) {
-    return packed;
-  }
-
-  const tailText = compactPlainTextForWeixin(tailChunks.join("\n")) || "已完成。";
-  if (tailText.length <= maxChunkChars) {
-    packed.push(tailText);
-    return packed;
-  }
-
-  const tailHardChunks = splitUtf8(tailText, maxChunkChars);
-  if (tailHardChunks.length === 1) {
-    packed.push(tailHardChunks[0]);
-    return packed;
-  }
-
-  const preserveCount = Math.max(0, maxMessages - tailHardChunks.length);
-  const preserved = normalizedChunks.slice(0, preserveCount);
-  const rebundledTail = normalizedChunks.slice(preserveCount);
-  const groupedTail = [];
-  let current = "";
-  for (const chunk of rebundledTail) {
-    const joined = current ? `${current}\n${chunk}` : chunk;
-    if (current && joined.length > maxChunkChars) {
-      groupedTail.push(current);
-      current = chunk;
-      continue;
-    }
-    current = joined;
-  }
-  if (current) {
-    groupedTail.push(current);
-  }
-
-  const normalizedGroupedTail = groupedTail.map((item) => compactPlainTextForWeixin(item) || "已完成。");
-  if (preserved.length + normalizedGroupedTail.length <= maxMessages) {
-    return preserved.concat(normalizedGroupedTail);
-  }
-
-  // Never silently drop the tail of a long reply. If grouping by semantic
-  // chunk boundaries still overflows the per-message budget, fall back to hard
-  // UTF-8 splits of the already-joined tail so the full answer is still sent.
-  return preserved.concat(tailHardChunks.slice(0, Math.max(1, maxMessages - preserved.length)));
-}
-
-function collectStreamingBoundaries(text) {
-  const boundaries = new Set();
-
-  const regex = /\n\s*\n+/g;
-  let match = regex.exec(text);
-  while (match) {
-    boundaries.add(match.index + match[0].length);
-    match = regex.exec(text);
-  }
-
-  const listRegex = /\n(?:(?:[-*])\s+|(?:\d+\.)\s+)/g;
-  match = listRegex.exec(text);
-  while (match) {
-    boundaries.add(match.index + 1);
-    match = listRegex.exec(text);
-  }
-
-  for (let index = 0; index < text.length; index += 1) {
-    const char = text[index];
-    if (!/[。！？!?]/.test(char)) {
-      continue;
-    }
-
-    let end = index + 1;
-    while (end < text.length && /["'”’）)\]」』】]/.test(text[end])) {
-      end += 1;
-    }
-    while (end < text.length && /[\t \n]/.test(text[end])) {
-      end += 1;
-    }
-    boundaries.add(end);
-  }
-
-  return Array.from(boundaries).sort((left, right) => left - right);
-}
-
-async function sendTextChunkWithRetry(send, { trace = null } = {}) {
-  let lastError = null;
-  for (let attempt = 0; attempt <= SEND_RETRY_DELAYS_MS.length; attempt += 1) {
-    const attemptNumber = attempt + 1;
-    try {
-      logWeixinSendTrace("attempt", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-      });
-      const result = await send();
-      logWeixinSendTrace("success", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-      });
-      return result;
-    } catch (error) {
-      lastError = error;
-      const retryable = isRetryableSendError(error);
-      logWeixinSendTrace("error", {
-        ...buildWeixinTraceContext(trace),
-        attempt: attemptNumber,
-        retryable,
-        error: String(error?.message || error || ""),
-      });
-      if (!retryable || attempt >= SEND_RETRY_DELAYS_MS.length) {
-        throw error;
-      }
-      await sleep(SEND_RETRY_DELAYS_MS[attempt]);
-    }
-  }
-  throw lastError || new Error("sendText chunk failed");
-}
-
-function sendLegacyTextChunk({
-  sendMessageImpl = sendMessage,
-  baseUrl,
-  token,
-  toUserId,
-  text,
-  contextToken,
-  clientId = "",
-  trace = null,
-}) {
-  const stableClientId = String(clientId || "").trim() || crypto.randomUUID();
-  return sendTextChunkWithRetry(
-    () => sendMessageImpl({
-      baseUrl,
-      token,
-      body: {
-        msg: {
-          client_id: stableClientId,
-          from_user_id: "",
-          to_user_id: toUserId,
-          message_type: 2,
-          message_state: 2,
-          item_list: [
-            {
-              type: 1,
-              text_item: { text: String(text || "") },
-            },
-          ],
-          context_token: contextToken,
-        },
-      },
-    }),
-    {
-      trace: buildWeixinTraceContext(trace, {
-        variant: "legacy",
-        clientId: stableClientId,
-        chars: String(text || "").length,
-        textHash: hashTraceText(text),
-      }),
-    }
-  );
-}
-
-function isRetryableSendError(error) {
-  const message = String(error?.message || error || "");
-  // Legacy sendmessage shows the same live ambiguity as v2: `ret=-2` can mean
-  // "client saw an error even though WeChat already accepted the message".
-  // Do not auto-retry it, or one failed bridge turn can fan out into duplicate
-  // bubbles on the user side.
-  return message.includes("AbortError")
-    || message.includes("aborted")
-    || message.includes("fetch failed")
-    || message.includes("ECONNRESET")
-    || message.includes("ETIMEDOUT")
-    || /http 5\d\d/.test(message);
-}
-
-function buildWeixinTraceContext(trace, defaults = {}) {
-  const normalizedTrace = normalizeTraceContext(trace);
-  return {
-    ...defaults,
-    ...normalizedTrace,
-    enabled: Boolean(normalizedTrace.enabled ?? defaults.enabled),
-    traceId: normalizeTraceText(normalizedTrace.traceId)
-      || normalizeTraceText(defaults.traceId)
-      || `wx-${crypto.randomUUID().slice(0, 8)}`,
-  };
-}
-
-function normalizeTraceContext(trace) {
-  if (!trace || typeof trace !== "object") {
-    return {};
-  }
-  return { ...trace };
-}
-
-function normalizeTraceText(value) {
-  return typeof value === "string" ? value.trim() : "";
-}
-
-function logWeixinSendTrace(stage, trace) {
-  if (!Boolean(trace?.enabled)) {
-    return;
-  }
-  const parts = [
+const crypto = require("crypto");
+const { listWeixinAccounts } = require("./account-store");
+const { resolveSelectedAccount } = require("./account-store");
+const { loadPersistedContextTokens, persistContextToken } = require("./context-token-store");
+const { runLegacyLoginFlow } = require("./login-legacy");
+const { getConfig, getUpdates, sendMessage, sendTyping } = require("./api");
+const { sendWeixinMediaFile } = require("./media-send");
+const { normalizeWeixinIncomingMessage } = require("./message-utils");
+const { loadSyncBuffer, saveSyncBuffer } = require("./sync-buffer-store");
+
+const LONG_POLL_TIMEOUT_MS = 35_000;
+const SEND_MESSAGE_CHUNK_INTERVAL_MS = 350;
+const WEIXIN_SEND_CHUNK_LIMIT = 80;
+const MAX_WEIXIN_CHUNK = 3800;
+const WEIXIN_MAX_DELIVERY_MESSAGES = 10;
+const SEND_RETRY_DELAYS_MS = [900, 1800];
+const AMBIGUOUS_SEND_RETRY_DELAYS_MS = [1200];
+
+function createLegacyWeixinChannelAdapter(config) {
+  let selectedAccount = null;
+  let contextTokenCache = null;
+
+  function ensureAccount() {
+    if (!selectedAccount) {
+      selectedAccount = resolveSelectedAccount(config);
+      contextTokenCache = loadPersistedContextTokens(config, selectedAccount.accountId);
+    }
+    return selectedAccount;
+  }
+
+  function ensureContextTokenCache() {
+    if (!contextTokenCache) {
+      const account = ensureAccount();
+      contextTokenCache = loadPersistedContextTokens(config, account.accountId);
+    }
+    return contextTokenCache;
+  }
+
+  function rememberContextToken(userId, contextToken) {
+    const account = ensureAccount();
+    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
+    const normalizedToken = typeof contextToken === "string" ? contextToken.trim() : "";
+    if (!normalizedUserId || !normalizedToken) {
+      return "";
+    }
+    contextTokenCache = persistContextToken(config, account.accountId, normalizedUserId, normalizedToken);
+    return normalizedToken;
+  }
+
+  function resolveContextToken(userId, explicitToken = "") {
+    const normalizedExplicitToken = typeof explicitToken === "string" ? explicitToken.trim() : "";
+    if (normalizedExplicitToken) {
+      return normalizedExplicitToken;
+    }
+    const normalizedUserId = typeof userId === "string" ? userId.trim() : "";
+    if (!normalizedUserId) {
+      return "";
+    }
+    return ensureContextTokenCache()[normalizedUserId] || "";
+  }
+
+  return {
+    describe() {
+      return {
+        id: "weixin",
+        variant: "legacy",
+        kind: "channel",
+        stateDir: config.stateDir,
+        baseUrl: config.weixinBaseUrl,
+        accountsDir: config.accountsDir,
+        syncBufferDir: config.syncBufferDir,
+      };
+    },
+    async login() {
+      await runLegacyLoginFlow(config);
+    },
+    printAccounts() {
+      const accounts = listWeixinAccounts(config);
+      if (!accounts.length) {
+        console.log("当前没有已保存的微信账号。先执行 `npm run login`。");
+        return;
+      }
+      console.log("已保存账号：");
+      for (const account of accounts) {
+        console.log(`- ${account.accountId}`);
+        console.log(`  userId: ${account.userId || "(unknown)"}`);
+        console.log(`  baseUrl: ${account.baseUrl || config.weixinBaseUrl}`);
+        if (account.routeTag) {
+          console.log(`  routeTag: ${account.routeTag}`);
+        }
+        console.log(`  savedAt: ${account.savedAt || "(unknown)"}`);
+      }
+    },
+    resolveAccount() {
+      return ensureAccount();
+    },
+    getKnownContextTokens() {
+      return { ...ensureContextTokenCache() };
+    },
+    loadSyncBuffer() {
+      const account = ensureAccount();
+      return loadSyncBuffer(config, account.accountId);
+    },
+    saveSyncBuffer(buffer) {
+      const account = ensureAccount();
+      saveSyncBuffer(config, account.accountId, buffer);
+    },
+    rememberContextToken,
+    async getUpdates({ syncBuffer = "", timeoutMs = LONG_POLL_TIMEOUT_MS } = {}) {
+      const account = ensureAccount();
+      const response = await getUpdates({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        get_updates_buf: syncBuffer,
+        timeoutMs,
+      });
+      if (typeof response?.get_updates_buf === "string" && response.get_updates_buf.trim()) {
+        this.saveSyncBuffer(response.get_updates_buf.trim());
+      }
+      const messages = Array.isArray(response?.msgs) ? response.msgs : [];
+      for (const message of messages) {
+        const userId = typeof message?.from_user_id === "string" ? message.from_user_id.trim() : "";
+        const contextToken = typeof message?.context_token === "string" ? message.context_token.trim() : "";
+        if (userId && contextToken) {
+          rememberContextToken(userId, contextToken);
+        }
+      }
+      return response;
+    },
+    normalizeIncomingMessage(message) {
+      const account = ensureAccount();
+      return normalizeWeixinIncomingMessage(message, config, account.accountId);
+    },
+    async sendText({ userId, text, contextToken = "", preserveBlock = false, trace = null }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        throw new Error(`缺少 context_token，无法回复用户 ${userId}`);
+      }
+      const content = String(text || "");
+      const sendChunks = preserveBlock
+        ? splitUtf8(compactPlainTextForWeixin(content) || "已完成。", MAX_WEIXIN_CHUNK)
+        : packChunksForWeixinDelivery(
+          chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT).length
+            ? chunkReplyTextForWeixin(content, WEIXIN_SEND_CHUNK_LIMIT)
+            : ["已完成。"],
+          WEIXIN_MAX_DELIVERY_MESSAGES,
+          MAX_WEIXIN_CHUNK
+        );
+      const traceContext = buildWeixinTraceContext(trace, {
+        enabled: config.weixinDeliveryTrace,
+        origin: "adapter.sendText",
+        variant: "legacy",
+        preserveBlock,
+        chunkTotal: sendChunks.length,
+      });
+      for (let index = 0; index < sendChunks.length; index += 1) {
+        const compactChunk = compactPlainTextForWeixin(sendChunks[index]) || "已完成。";
+        const clientId = crypto.randomUUID();
+        await sendLegacyTextChunk({
+          baseUrl: account.baseUrl,
+          token: account.token,
+          toUserId: userId,
+          text: compactChunk,
+          contextToken: resolvedToken,
+          clientId,
+          trace: {
+            ...traceContext,
+            chunkIndex: index + 1,
+            chars: compactChunk.length,
+            textHash: hashTraceText(compactChunk),
+            clientId,
+          },
+        });
+        if (index < sendChunks.length - 1) {
+          await sleep(SEND_MESSAGE_CHUNK_INTERVAL_MS);
+        }
+      }
+    },
+    async sendTyping({ userId, status = 1, contextToken = "" }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        return;
+      }
+      const configResponse = await getConfig({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        ilinkUserId: userId,
+        contextToken: resolvedToken,
+      }).catch(() => null);
+      const typingTicket = typeof configResponse?.typing_ticket === "string"
+        ? configResponse.typing_ticket.trim()
+        : "";
+      if (!typingTicket) {
+        return;
+      }
+      await sendTyping({
+        baseUrl: account.baseUrl,
+        token: account.token,
+        body: {
+          ilink_user_id: userId,
+          typing_ticket: typingTicket,
+          status,
+        },
+      });
+    },
+    async sendFile({ userId, filePath, contextToken = "" }) {
+      const account = ensureAccount();
+      const resolvedToken = resolveContextToken(userId, contextToken);
+      if (!resolvedToken) {
+        throw new Error(`缺少 context_token，无法发送文件给用户 ${userId}`);
+      }
+      return sendWeixinMediaFile({
+        filePath,
+        to: userId,
+        contextToken: resolvedToken,
+        baseUrl: account.baseUrl,
+        token: account.token,
+        cdnBaseUrl: config.weixinCdnBaseUrl,
+      });
+    },
+  };
+}
+
+function splitUtf8(text, maxRunes) {
+  const runes = Array.from(String(text || ""));
+  if (!runes.length || runes.length <= maxRunes) {
+    return [String(text || "")];
+  }
+  const chunks = [];
+  while (runes.length) {
+    chunks.push(runes.splice(0, maxRunes).join(""));
+  }
+  return chunks;
+}
+
+function compactPlainTextForWeixin(text) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n");
+  return trimOuterBlankLines(normalized.replace(/\n\s*\n+/g, "\n"));
+}
+
+function chunkReplyText(text, limit = 3500) {
+  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
+  if (!normalized.trim()) {
+    return [];
+  }
+
+  const chunks = [];
+  let remaining = normalized;
+  while (remaining.length > limit) {
+    const candidate = remaining.slice(0, limit);
+    const splitIndex = Math.max(
+      candidate.lastIndexOf("\n\n"),
+      candidate.lastIndexOf("\n"),
+      candidate.lastIndexOf("。"),
+      candidate.lastIndexOf(". "),
+      candidate.lastIndexOf(" ")
+    );
+    const cut = splitIndex > limit * 0.4 ? splitIndex + (candidate[splitIndex] === "\n" ? 0 : 1) : limit;
+    const chunk = trimOuterBlankLines(remaining.slice(0, cut));
+    if (chunk.trim()) {
+      chunks.push(chunk);
+    }
+    remaining = trimOuterBlankLines(remaining.slice(cut));
+  }
+  if (remaining) {
+    chunks.push(remaining);
+  }
+  return chunks.filter(Boolean);
+}
+
+function chunkReplyTextForWeixin(text, limit = 80) {
+  const normalized = trimOuterBlankLines(String(text || "").replace(/\r\n/g, "\n"));
+  if (!normalized.trim()) {
+    return [];
+  }
+
+  const boundaries = collectStreamingBoundaries(normalized);
+  if (!boundaries.length) {
+    return chunkReplyText(normalized, limit);
+  }
+
+  const units = [];
+  let start = 0;
+  for (const boundary of boundaries) {
+    if (boundary <= start) {
+      continue;
+    }
+    const unit = trimOuterBlankLines(normalized.slice(start, boundary));
+    if (unit) {
+      units.push(unit);
+    }
+    start = boundary;
+  }
+
+  const tail = trimOuterBlankLines(normalized.slice(start));
+  if (tail) {
+    units.push(tail);
+  }
+
+  if (!units.length) {
+    return chunkReplyText(normalized, limit);
+  }
+
+  const chunks = [];
+  for (const unit of units) {
+    if (unit.length <= limit) {
+      chunks.push(unit);
+      continue;
+    }
+    chunks.push(...chunkReplyText(unit, limit));
+  }
+  return chunks.filter(Boolean);
+}
+
+function packChunksForWeixinDelivery(chunks, maxMessages = 10, maxChunkChars = 3800) {
+  const normalizedChunks = Array.isArray(chunks)
+    ? chunks.map((chunk) => compactPlainTextForWeixin(chunk)).filter(Boolean)
+    : [];
+  if (!normalizedChunks.length) {
+    return normalizedChunks;
+  }
+
+  const groupedChunks = groupChunksWithinBudget(normalizedChunks, maxChunkChars);
+  if (groupedChunks.length <= maxMessages) {
+    return groupedChunks;
+  }
+
+  const fullText = compactPlainTextForWeixin(normalizedChunks.join("\n")) || "已完成。";
+  const hardChunks = splitUtf8(fullText, maxChunkChars);
+  if (hardChunks.length <= maxMessages) {
+    return hardChunks;
+  }
+
+  // `maxMessages` is only a spam guard. If the full reply still needs more
+  // chunks at the hard per-message budget, prefer complete delivery over
+  // silently dropping the tail.
+  return hardChunks;
+}
+
+function groupChunksWithinBudget(chunks, maxChunkChars) {
+  const grouped = [];
+  let current = "";
+
+  for (const rawChunk of Array.isArray(chunks) ? chunks : []) {
+    const normalizedChunk = compactPlainTextForWeixin(rawChunk);
+    if (!normalizedChunk) {
+      continue;
+    }
+
+    const units = normalizedChunk.length > maxChunkChars
+      ? splitUtf8(normalizedChunk, maxChunkChars)
+      : [normalizedChunk];
+
+    for (const unit of units) {
+      if (!current) {
+        current = unit;
+        continue;
+      }
+      const joined = `${current}\n${unit}`;
+      if (joined.length > maxChunkChars) {
+        grouped.push(current);
+        current = unit;
+        continue;
+      }
+      current = joined;
+    }
+  }
+
+  if (current) {
+    grouped.push(current);
+  }
+  return grouped;
+}
+
+function collectStreamingBoundaries(text) {
+  const boundaries = new Set();
+
+  const regex = /\n\s*\n+/g;
+  let match = regex.exec(text);
+  while (match) {
+    boundaries.add(match.index + match[0].length);
+    match = regex.exec(text);
+  }
+
+  const listRegex = /\n(?:(?:[-*])\s+|(?:\d+\.)\s+)/g;
+  match = listRegex.exec(text);
+  while (match) {
+    boundaries.add(match.index + 1);
+    match = listRegex.exec(text);
+  }
+
+  for (let index = 0; index < text.length; index += 1) {
+    const char = text[index];
+    if (!/[。！？!?]/.test(char)) {
+      continue;
+    }
+
+    let end = index + 1;
+    while (end < text.length && /["'”’）)\]」』】]/.test(text[end])) {
+      end += 1;
+    }
+    while (end < text.length && /[\t \n]/.test(text[end])) {
+      end += 1;
+    }
+    boundaries.add(end);
+  }
+
+  return Array.from(boundaries).sort((left, right) => left - right);
+}
+
+async function sendTextChunkWithRetry(send, { trace = null } = {}) {
+  let lastError = null;
+  for (let attempt = 0; ; attempt += 1) {
+    const attemptNumber = attempt + 1;
+    try {
+      logWeixinSendTrace("attempt", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+      });
+      const result = await send();
+      logWeixinSendTrace("success", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+      });
+      return result;
+    } catch (error) {
+      lastError = error;
+      const retryDelays = getSendRetryDelaysMs(error);
+      const retryable = attempt < retryDelays.length;
+      logWeixinSendTrace("error", {
+        ...buildWeixinTraceContext(trace),
+        attempt: attemptNumber,
+        retryable,
+        error: String(error?.message || error || ""),
+      });
+      if (!retryable) {
+        throw error;
+      }
+      await sleep(retryDelays[attempt]);
+    }
+  }
+  throw lastError || new Error("sendText chunk failed");
+}
+
+function sendLegacyTextChunk({
+  sendMessageImpl = sendMessage,
+  baseUrl,
+  token,
+  toUserId,
+  text,
+  contextToken,
+  clientId = "",
+  trace = null,
+}) {
+  const stableClientId = String(clientId || "").trim() || crypto.randomUUID();
+  return sendTextChunkWithRetry(
+    () => sendMessageImpl({
+      baseUrl,
+      token,
+      body: {
+        msg: {
+          client_id: stableClientId,
+          from_user_id: "",
+          to_user_id: toUserId,
+          message_type: 2,
+          message_state: 2,
+          item_list: [
+            {
+              type: 1,
+              text_item: { text: String(text || "") },
+            },
+          ],
+          context_token: contextToken,
+        },
+      },
+    }),
+    {
+      trace: buildWeixinTraceContext(trace, {
+        variant: "legacy",
+        clientId: stableClientId,
+        chars: String(text || "").length,
+        textHash: hashTraceText(text),
+      }),
+    }
+  );
+}
+
+function getSendRetryDelaysMs(error) {
+  const message = String(error?.message || error || "");
+  // Legacy sendmessage sees the same `ret=-2` ambiguity as v2. Retry it once
+  // with the same client_id so we bias toward complete delivery without
+  // turning one flaky send into a burst of duplicate assistant bubbles.
+  if (message.includes("ret=-2")) {
+    return AMBIGUOUS_SEND_RETRY_DELAYS_MS;
+  }
+  if (message.includes("AbortError")
+    || message.includes("aborted")
+    || message.includes("fetch failed")
+    || message.includes("ECONNRESET")
+    || message.includes("ETIMEDOUT")
+    || /http 5\d\d/.test(message)) {
+    return SEND_RETRY_DELAYS_MS;
+  }
+  return [];
+}
+
+function buildWeixinTraceContext(trace, defaults = {}) {
+  const normalizedTrace = normalizeTraceContext(trace);
+  return {
+    ...defaults,
+    ...normalizedTrace,
+    enabled: Boolean(normalizedTrace.enabled ?? defaults.enabled),
+    traceId: normalizeTraceText(normalizedTrace.traceId)
+      || normalizeTraceText(defaults.traceId)
+      || `wx-${crypto.randomUUID().slice(0, 8)}`,
+  };
+}
+
+function normalizeTraceContext(trace) {
+  if (!trace || typeof trace !== "object") {
+    return {};
+  }
+  return { ...trace };
+}
+
+function normalizeTraceText(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function logWeixinSendTrace(stage, trace) {
+  if (!Boolean(trace?.enabled)) {
+    return;
+  }
+  const parts = [
     `[codeksei] weixin send trace stage=${stage}`,
-    `pid=${process.pid}`,
-    `trace=${trace.traceId || "(none)"}`,
-    `origin=${trace.origin || "adapter.sendText"}`,
-    `variant=${trace.variant || "legacy"}`,
-    trace.threadId ? `thread=${trace.threadId}` : "",
-    `turn=${trace.turnId || "(pending)"}`,
-    trace.mode ? `mode=${trace.mode}` : "",
-    trace.trigger ? `trigger=${trace.trigger}` : "",
-    `chunk=${trace.chunkIndex || 1}/${trace.chunkTotal || 1}`,
-    `preserveBlock=${trace.preserveBlock ? "1" : "0"}`,
-    `attempt=${trace.attempt || 1}`,
-    trace.retryable === undefined ? "" : `retryable=${trace.retryable ? "1" : "0"}`,
-    `clientId=${trace.clientId || "(none)"}`,
-    `chars=${trace.chars || 0}`,
-    `hash=${trace.textHash || hashTraceText("")}`,
-  ].filter(Boolean);
-  if (trace.error) {
-    parts.push(`error=${JSON.stringify(String(trace.error || ""))}`);
-    console.error(parts.join(" "));
-    return;
-  }
-  console.log(parts.join(" "));
-}
-
-function hashTraceText(text) {
-  return crypto.createHash("sha1").update(String(text || ""), "utf8").digest("hex").slice(0, 12);
-}
-
-function trimOuterBlankLines(text) {
-  return String(text || "")
-    .replace(/^\s*\n+/g, "")
-    .replace(/\n+\s*$/g, "");
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-module.exports = {
-  createLegacyWeixinChannelAdapter,
-  sendLegacyTextChunk,
-};
+    `pid=${process.pid}`,
+    `trace=${trace.traceId || "(none)"}`,
+    `origin=${trace.origin || "adapter.sendText"}`,
+    `variant=${trace.variant || "legacy"}`,
+    trace.threadId ? `thread=${trace.threadId}` : "",
+    `turn=${trace.turnId || "(pending)"}`,
+    trace.mode ? `mode=${trace.mode}` : "",
+    trace.trigger ? `trigger=${trace.trigger}` : "",
+    `chunk=${trace.chunkIndex || 1}/${trace.chunkTotal || 1}`,
+    `preserveBlock=${trace.preserveBlock ? "1" : "0"}`,
+    `attempt=${trace.attempt || 1}`,
+    trace.retryable === undefined ? "" : `retryable=${trace.retryable ? "1" : "0"}`,
+    `clientId=${trace.clientId || "(none)"}`,
+    `chars=${trace.chars || 0}`,
+    `hash=${trace.textHash || hashTraceText("")}`,
+  ].filter(Boolean);
+  if (trace.error) {
+    parts.push(`error=${JSON.stringify(String(trace.error || ""))}`);
+    console.error(parts.join(" "));
+    return;
+  }
+  console.log(parts.join(" "));
+}
+
+function hashTraceText(text) {
+  return crypto.createHash("sha1").update(String(text || ""), "utf8").digest("hex").slice(0, 12);
+}
+
+function trimOuterBlankLines(text) {
+  return String(text || "")
+    .replace(/^\s*\n+/g, "")
+    .replace(/\n+\s*$/g, "");
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  createLegacyWeixinChannelAdapter,
+  packChunksForWeixinDelivery,
+  sendLegacyTextChunk,
+};