@lynn123411/dsh-chat-translate 1.3.2 → 1.7.0

package/lib/index.js

@@ -786,7 +786,7 @@ defineMethod("transform", [
   "preserve"
 ], ({ inner }, isInner) => inner.toString(isInner));
 
-// node_modules/.pnpm/@deepseek-ai+dsh-home-paths@0.1.5-rc.1_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-home-paths/lib/index.js
+// node_modules/.pnpm/@deepseek-ai+dsh-home-paths@0.1.6-alpha.2_@deepseek-ai+cordis@4.0.2/node_modules/@deepseek-ai/dsh-home-paths/lib/index.js
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve as resolve2 } from "node:path";
 var DSH_HOME_DIR_NAME = ".dsh";
@@ -813,14 +813,19 @@ import * as fs from "node:fs/promises";
 var MAX_CONCURRENCY = 100;
 var AI_TIMEOUT_MIN = 500;
 var AI_TIMEOUT_MAX = 12e4;
+var THINK_TIMEOUT_MIN = 500;
+var THINK_TIMEOUT_MAX = 9e5;
+var THINK_CACHE_ENTRIES = 300;
 var SETTINGS_NAMESPACE = "dsh-chat-translate";
 var DEFAULT_CONFIG = {
   enabled: true,
   concurrency: 3,
   timeoutMs: 2e3,
   aiTimeoutMs: 3e4,
+  thinkTimeoutMs: 6e5,
   aiEnabled: true,
   bingEnabled: true,
+  thinkEnabled: true,
   baseUrl: "",
   model: "",
   targetLang: "zh-Hans"
@@ -865,6 +870,7 @@ function sanitizePatch(input) {
   if (typeof input.enabled === "boolean") next.enabled = input.enabled;
   if (typeof input.aiEnabled === "boolean") next.aiEnabled = input.aiEnabled;
   if (typeof input.bingEnabled === "boolean") next.bingEnabled = input.bingEnabled;
+  if (typeof input.thinkEnabled === "boolean") next.thinkEnabled = input.thinkEnabled;
   if (typeof input.concurrency === "number" && Number.isFinite(input.concurrency)) {
     next.concurrency = Math.min(Math.max(Math.round(input.concurrency), 1), MAX_CONCURRENCY);
   }
@@ -877,6 +883,12 @@ function sanitizePatch(input) {
       AI_TIMEOUT_MAX
     );
   }
+  if (typeof input.thinkTimeoutMs === "number" && Number.isFinite(input.thinkTimeoutMs)) {
+    next.thinkTimeoutMs = Math.min(
+      Math.max(Math.round(input.thinkTimeoutMs), THINK_TIMEOUT_MIN),
+      THINK_TIMEOUT_MAX
+    );
+  }
   if (typeof input.baseUrl === "string") next.baseUrl = input.baseUrl.trim();
   if (typeof input.model === "string") next.model = input.model.trim();
   if (typeof input.targetLang === "string" && input.targetLang.trim()) {
@@ -912,13 +924,18 @@ async function migrateLegacyConfigFile(settings, legacyPath) {
     return false;
   }
   const patch = sanitizePatch(record);
-  if (Object.keys(patch).length === 0) {
+  const ops = Object.entries(patch).map(([field, value]) => ({
+    op: "set",
+    path: [field],
+    value
+  }));
+  if (ops.length === 0) {
     await fs.unlink(legacyPath).catch(() => {
     });
     return false;
   }
   try {
-    await settings.update(SETTINGS_NAMESPACE, patch);
+    await settings.mutate(SETTINGS_NAMESPACE, ops, descriptor?.revision);
   } catch (err) {
     console.warn("[dsh-chat-translate] Legacy config migration failed; will retry on next boot:", err);
     return false;
@@ -1010,117 +1027,180 @@ function createMaskTokenFormat() {
   const id = randomTokenId();
   return {
     id,
-    token: (index) => `__DSHMASKx${id}_${index}__`
+    token: (index) => `\u27E6${id}${index}\u27E7`
   };
 }
-var MASK_TOKEN_PATTERN_SOURCE = "_*\\s*DSH\\s*_*\\s*MASK\\s*(?:_?\\s*(\\d+)|_*[xX]?[\\s._-]*([a-z]{2,8})\\s*_+\\s*(\\d+))(?:_{0,2}(?=[^\\w]|$))?";
+var MASK_TOKEN_PATTERN_SOURCE = "\u27E6([a-z]{4})(\\d+)\u27E7";
+var MASK_TOKEN_PREFIX_PATTERN_SOURCE = "\u27E6\\s*([a-z]{4})(\\d+)";
+var LEGACY_MASK_PATTERN_SOURCE = "_{1,2}DSH\\s*_*\\s*MASKx?\\s*(?:_?\\s*\\d+|_*([a-z]{2,8})\\s*_+\\s*(\\d+))_{0,2}";
+var LEGACY_MASK_TOKEN_PATTERN_SOURCE = LEGACY_MASK_PATTERN_SOURCE;
 function matchMaskToken(text, start, id) {
-  const anchored = new RegExp(`^(?:${MASK_TOKEN_PATTERN_SOURCE})`, "i").exec(text.slice(start));
+  const complete = new RegExp(`^(?:${MASK_TOKEN_PATTERN_SOURCE})`, "iu").exec(text.slice(start));
+  const truncated = complete ? null : new RegExp(`^(?:${MASK_TOKEN_PREFIX_PATTERN_SOURCE})`, "iu").exec(text.slice(start));
+  const anchored = complete ?? truncated;
   if (!anchored) return null;
-  const index = Number.parseInt(anchored[1] ?? anchored[3] ?? "", 10);
+  if (anchored[1].toLowerCase() !== id.toLowerCase()) return null;
+  const index = Number.parseInt(anchored[2], 10);
   if (Number.isNaN(index)) return null;
-  const tokenId = anchored[2];
-  const acceptsId = tokenId === void 0 || tokenId.toLowerCase() === id.toLowerCase();
-  return { index, acceptsId, length: anchored[0].length };
+  return { index, length: anchored[0].length, truncated: complete === null };
 }
 function hasMaskResidue(text) {
   if (!text) return false;
-  return new RegExp(MASK_TOKEN_PATTERN_SOURCE, "i").test(text);
+  return new RegExp(MASK_TOKEN_PATTERN_SOURCE, "iu").test(text);
 }
-function maskResidues(text) {
-  if (!text) return [];
-  return text.match(new RegExp(MASK_TOKEN_PATTERN_SOURCE, "gi")) ?? [];
+function hasLegacyMaskResidue(text) {
+  if (!text) return false;
+  return new RegExp(LEGACY_MASK_PATTERN_SOURCE, "iu").test(text);
 }
-function hasNewMaskResidue(originalText, translatedText) {
-  const residues = maskResidues(translatedText);
-  if (residues.length === 0) return false;
-  const presentInSource = /* @__PURE__ */ new Map();
-  for (const fragment of maskResidues(originalText)) {
-    const key = fragment.toLowerCase();
-    presentInSource.set(key, (presentInSource.get(key) ?? 0) + 1);
-  }
-  for (const fragment of residues) {
-    const key = fragment.toLowerCase();
-    const remaining = presentInSource.get(key) ?? 0;
-    if (remaining === 0) return true;
-    presentInSource.set(key, remaining - 1);
-  }
-  return false;
+function hasAnyMaskResidue(text) {
+  return hasMaskResidue(text) || hasLegacyMaskResidue(text);
+}
+function findLegacyMaskTokens(text) {
+  if (!text) return [];
+  return text.match(new RegExp(LEGACY_MASK_TOKEN_PATTERN_SOURCE, "giu")) ?? [];
 }
 
 // src/server/pipeline/masking.ts
-var MASK_MARKER = /DSH\s*_?\s*MASK/i;
 var MAX_UNMASK_PASSES = 1e4;
+var ASCII_WORD = /[A-Za-z0-9_]/;
+var INSERTED_SPACE = /^ | $/;
+var MaskRestoreError = class extends Error {
+  expectedCount;
+  foundCount;
+  constructor(message, expectedCount, foundCount) {
+    super(message);
+    this.name = "MaskRestoreError";
+    this.expectedCount = expectedCount;
+    this.foundCount = foundCount;
+  }
+};
 var ContentMaskingPipeline = class {
   mask(text) {
     if (!text || typeof text !== "string") {
       return {
         maskedText: text,
-        unmask: (t) => t
+        unmask: (t) => t,
+        legacyFragments: []
       };
     }
     const masks = [];
+    const legacyIndexes = /* @__PURE__ */ new Set();
+    const inserted = [];
     const format = createMaskTokenFormat();
-    const addMask = (match) => {
-      if (MASK_MARKER.test(match)) return match;
-      const idx = masks.length;
+    const addFragment = (match, before, after, onPlace) => {
+      if (hasMaskResidue(match)) return match;
+      const index = masks.length;
       masks.push(match);
-      return format.token(idx);
+      const leading = before !== void 0 && ASCII_WORD.test(before);
+      const trailing = after !== void 0 && ASCII_WORD.test(after);
+      inserted.push({ leading, trailing });
+      onPlace?.(index);
+      return `${leading ? " " : ""}${format.token(index)}${trailing ? " " : ""}`;
     };
-    let processed = text;
-    processed = processed.replace(/(?:```|~~~)[\s\S]*?(?:```|~~~)/g, (m) => addMask(m));
-    processed = processed.replace(/`[^`\n]+`/g, (m) => addMask(m));
-    processed = processed.replace(/https?:\/\/[^\s)\];,;"'<>]+/g, (m) => addMask(m));
-    processed = processed.replace(
-      /(?:\/[\w.\-\\\/]+|(?<=[\w.\-])\.\.?[\\\/][\w.\-\\\/]+|(?<=^|[\s([{"'`])[a-zA-Z]:[\\\/][\w.\-\\\/]+|(?<![^\s([{"'`])\b(?:[\w.\-]+\/)+[\w.\-]+\.[a-zA-Z0-9]+\b|(?<![^\s([{"'`])\b[\w.\-]+\.(?:ts|tsx|js|jsx|json|ya?ml|md|py|go|rs|c|cpp|h|hpp|css|scss|html|sh|bash|mjs|cjs|toml|lock|log|env|svg|png|jpe?g|gif|tar|gz|zip|xml|sql)\b)/g,
-      (m) => addMask(m)
+    const wrapRule = (input, pattern2, onPlace) => input.replace(pattern2, (...args) => {
+      const match = args[0];
+      const offset = args[args.length - 2];
+      const whole = args[args.length - 1];
+      return addFragment(match, whole[offset - 1], whole[offset + match.length], onPlace);
+    });
+    let processed = wrapRule(
+      text,
+      new RegExp(LEGACY_MASK_TOKEN_PATTERN_SOURCE, "giu"),
+      (index) => legacyIndexes.add(index)
+    );
+    processed = wrapRule(processed, /(?:```|~~~)[\s\S]*?(?:```|~~~)/g);
+    processed = wrapRule(processed, /`[^`\n]+`/g);
+    processed = wrapRule(processed, /https?:\/\/[^\s)\];,;"'<>]+/g);
+    processed = wrapRule(
+      processed,
+      /(?:\/[\w.\-\\\/]+|(?<=[\w.\-])\.\.?[\\\/][\w.\-\\\/]+|(?<=^|[\s([{"'`])[a-zA-Z]:[\\\/][\w.\-\\\/]+|(?<![^\s([{"'`])\b(?:[\w.\-]+\/)+[\w.\-]+\.[a-zA-Z0-9]+\b|(?<![^\s([{"'`])\b[\w.\-]+\.(?:ts|tsx|js|jsx|json|ya?ml|md|py|go|rs|c|cpp|h|hpp|css|scss|html|sh|bash|mjs|cjs|toml|lock|log|env|svg|png|jpe?g|gif|tar|gz|zip|xml|sql)\b)/g
     );
-    processed = processed.replace(
-      /(?<=^|[\s(\[{"'])((?:--[a-zA-Z0-9_\-]+(?:=[^\s"'<>]+)?)|(?:-[a-zA-Z0-9]+))(?=[\s)\]}",:;!?]|$)/g,
-      (m) => addMask(m)
+    processed = wrapRule(
+      processed,
+      /(?<=^|[\s(\[{"'])((?:--[a-zA-Z0-9_\-]+(?:=[^\s"'<>]+)?)|(?:-[a-zA-Z0-9]+))(?=[\s)\]}",:;!?]|$)/g
     );
     const unmask = (translatedText) => {
-      if (!translatedText || masks.length === 0) {
+      if (!translatedText) return translatedText;
+      if (masks.length === 0) {
+        if (hasAnyMaskResidue(translatedText)) {
+          throw new MaskRestoreError(
+            "translation carries a mask token while the source had none",
+            0,
+            0
+          );
+        }
         return translatedText;
       }
-      return replaceMaskTokens(
-        translatedText,
-        format.id,
-        (index) => index >= 0 && index < masks.length ? masks[index] : void 0
-      );
+      return replaceMaskTokens(translatedText, format.id, masks, inserted, legacyIndexes);
     };
     return {
       maskedText: processed,
-      unmask
+      unmask,
+      legacyFragments: [...legacyIndexes].map((index) => masks[index]).filter((f) => f !== void 0)
     };
   }
 };
-function replaceMaskTokens(text, id, resolve3) {
-  const pattern2 = new RegExp(MASK_TOKEN_PATTERN_SOURCE, "i");
+function replaceMaskTokens(text, id, masks, inserted, legacyIndexes = /* @__PURE__ */ new Set()) {
+  const complete = new RegExp(MASK_TOKEN_PATTERN_SOURCE, "giu");
+  const prefix = new RegExp(MASK_TOKEN_PREFIX_PATTERN_SOURCE, "giu");
+  const seen = /* @__PURE__ */ new Set();
   let out = "";
   let cursor = 0;
   let passes = 0;
-  while (cursor < text.length && passes++ < MAX_UNMASK_PASSES) {
-    const candidate = pattern2.exec(text.slice(cursor));
-    if (!candidate) break;
-    const start = cursor + candidate.index;
+  let whole = complete.exec(text);
+  let prefixCandidate = prefix.exec(text);
+  const nextStart = (wholeMatch, prefixMatch) => Math.min(
+    wholeMatch ? wholeMatch.index : Number.POSITIVE_INFINITY,
+    prefixMatch ? prefixMatch.index : Number.POSITIVE_INFINITY
+  );
+  let start = nextStart(whole, prefixCandidate);
+  while (start !== Number.POSITIVE_INFINITY && passes++ < MAX_UNMASK_PASSES) {
+    const isPrefix = prefixCandidate !== null && prefixCandidate.index === start && whole?.index !== start;
+    const raw = isPrefix ? prefixCandidate[0] : whole[0];
     const match = matchMaskToken(text, start, id);
-    const length = match?.length ?? candidate[0].length;
-    if (length <= 0) {
-      cursor = start + 1;
-      continue;
+    if (!match) {
+      out += text.slice(cursor, start) + raw;
+      cursor = start + raw.length;
+    } else {
+      if (match.index < 0 || match.index >= masks.length || seen.has(match.index)) {
+        throw new MaskRestoreError(
+          `translation does not reproduce every protected fragment (bad index ${match.index})`,
+          masks.length,
+          seen.size
+        );
+      }
+      seen.add(match.index);
+      const spacing = isPrefix ? void 0 : inserted?.[match.index];
+      let before = text.slice(cursor, start);
+      if (spacing?.leading) before = before.replace(INSERTED_SPACE, "");
+      if (spacing?.trailing) out = out.replace(INSERTED_SPACE, "");
+      out += before + masks[match.index];
+      cursor = start + raw.length;
     }
-    const replacement = match?.acceptsId ? resolve3(match.index) : void 0;
-    out += text.slice(cursor, start) + (replacement ?? text.slice(start, start + length));
-    cursor = start + length;
+    while (whole && whole.index < cursor) whole = complete.exec(text);
+    while (prefixCandidate && prefixCandidate.index < cursor) prefixCandidate = prefix.exec(text);
+    start = nextStart(whole, prefixCandidate);
+  }
+  out += text.slice(cursor);
+  const documented = /* @__PURE__ */ new Set();
+  for (const index of legacyIndexes) {
+    const fragment = masks[index];
+    if (fragment !== void 0) documented.add(fragment.toLowerCase());
+  }
+  const residue = (out.match(new RegExp(LEGACY_MASK_TOKEN_PATTERN_SOURCE, "giu")) ?? []).filter(
+    (fragment) => !documented.has(fragment.toLowerCase())
+  );
+  if (seen.size !== masks.length || hasMaskResidue(out) || residue.length > 0) {
+    throw new MaskRestoreError(
+      `translation does not reproduce every protected fragment (expected ${masks.length}, found ${seen.size})`,
+      masks.length,
+      seen.size
+    );
   }
-  return out + text.slice(cursor);
+  return out;
 }
 function isMaskLeak(translatedText) {
-  return hasMaskResidue(translatedText);
-}
-function isMaskLeakAgainst(originalText, translatedText) {
-  return hasNewMaskResidue(originalText, translatedText);
+  return hasAnyMaskResidue(translatedText);
 }
 
 // src/server/cache.ts
@@ -1133,12 +1213,19 @@ var LruDiskCache = class {
   dirty = false;
   /** Legacy root-level cache file (<=1.1); moved under the plugin subdir. */
   legacyPath;
-  constructor(maxEntries = 1e3) {
+  /** Only the original title cache carries a pre-1.2 root-level predecessor. */
+  hasLegacyPredecessor;
+  constructor(maxEntries = 1e3, fileName = "cache.json") {
     this.maxEntries = maxEntries;
-    this.filePath = dshHomePath("dsh-chat-translate", "cache.json");
+    this.filePath = dshHomePath("dsh-chat-translate", fileName);
     this.legacyPath = dshHomePath("dsh-chat-translate-cache.json");
+    this.hasLegacyPredecessor = fileName === "cache.json";
   }
   async init() {
+    if (!this.hasLegacyPredecessor) {
+      await this.loadFile(this.filePath);
+      return;
+    }
     let readPath = this.filePath;
     try {
       await fs2.access(this.filePath);
@@ -1153,6 +1240,14 @@ var LruDiskCache = class {
         readPath = this.legacyPath;
       }
     }
+    await this.loadFile(readPath);
+    if (readPath !== this.filePath) {
+      await fs2.unlink(this.legacyPath).catch(() => {
+      });
+    }
+  }
+  /** Load one cache document into memory, dropping poisoned or malformed entries. */
+  async loadFile(readPath) {
     try {
       const content = await fs2.readFile(readPath, "utf-8");
       const obj = JSON.parse(content);
@@ -1170,10 +1265,6 @@ var LruDiskCache = class {
       }
     } catch {
     }
-    if (readPath !== this.filePath) {
-      await fs2.unlink(this.legacyPath).catch(() => {
-      });
-    }
   }
   get(key) {
     const entry = this.cache.get(key);
@@ -1421,6 +1512,11 @@ var LANG_HINTS = {
   pt: "Portuguese",
   it: "Italian"
 };
+function buildSystemPrompt(langName, mode) {
+  const base = `You are a professional translator. Translate the user's message into ${langName}. Output ONLY the translated text \u2014 no explanations, no quotation marks, no extra words. Some fragments of the message are opaque code between the bracket characters U+27E6 and U+27E7. Copy each such fragment into your output character-for-character, keeping its position in the sentence. Never invent such a fragment and never remove one.`;
+  if (mode === "plain") return base;
+  return base + ` The message is a sequence of parts. Each part starts with its own line holding a marker: an index between the bracket characters U+27EA and U+27EB. For every part, output its marker line unchanged, then that part's translation on the following lines. Translate each part on its own, keep the parts in the original order, and never merge two parts into one answer.`;
+}
 var OpenAiCompatibleAdapter = class {
   id = "openai";
   name = "OpenAI \u517C\u5BB9 (Chat Completions)";
@@ -1433,7 +1529,7 @@ var OpenAiCompatibleAdapter = class {
       config.aiEnabled && config.baseUrl?.trim() && config.model?.trim() && this.credentials.getApiKey()
     );
   }
-  async translate(text, signal, config) {
+  async translate(text, signal, config, options) {
     const apiKey = this.credentials.getApiKey();
     if (!apiKey) {
       throw new Error(`TRANSLATE_API_KEY is not configured in ~/.dsh/.credentials.yaml`);
@@ -1453,11 +1549,9 @@ var OpenAiCompatibleAdapter = class {
       body: JSON.stringify({
         model,
         temperature: 0,
+        ...options?.maxTokens === void 0 ? {} : { max_tokens: options.maxTokens },
         messages: [
-          {
-            role: "system",
-            content: `You are a professional translator. Translate the user's message into ${langName}. Output ONLY the translated text \u2014 no explanations, no quotation marks, no extra words. Some parts of the message are replaced by opaque placeholder markers (an uppercase token starting with "DSH" surrounded by double underscores). Copy every such marker into your output character-for-character, unchanged and in place. Never invent a marker that is not present in the message and never remove one.`
-          },
+          { role: "system", content: buildSystemPrompt(langName, options?.mode ?? "plain") },
           { role: "user", content: text }
         ]
       }),
@@ -1482,10 +1576,138 @@ var OpenAiCompatibleAdapter = class {
   }
 };
 
+// src/server/pipeline/think.ts
+var THINK_MAX_INPUT_TOKENS = 4096;
+var THINK_MAX_OUTPUT_TOKENS = 8192;
+var CJK_CHAR = /[\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff\u3000-\u303f\uff00-\uffef]/;
+function estimateTokens(text) {
+  let cjk = 0;
+  for (const char of text) {
+    if (CJK_CHAR.test(char)) cjk += 1;
+  }
+  return cjk + Math.ceil((text.length - cjk) / 3);
+}
+function splitKeepingSeparator(text, pattern2) {
+  const parts = text.split(pattern2);
+  const chunks = [];
+  for (let index = 0; index < parts.length; index += 2) {
+    const content = parts[index] ?? "";
+    const separator = parts[index + 1] ?? "";
+    if (content === "" && separator === "") continue;
+    chunks.push(content + separator);
+  }
+  return chunks;
+}
+function sentenceChunks(text) {
+  const chunks = text.match(/[^.!?。！？\n]+[.!?。！？]*[ \t]*\n?/g);
+  return chunks === null ? [text] : chunks.filter((chunk) => chunk.length > 0);
+}
+function hardSlice(text, maxTokens) {
+  const out = [];
+  let current = "";
+  let tokens = 0;
+  for (const char of text) {
+    const cost = CJK_CHAR.test(char) ? 1 : 1 / 3;
+    if (current !== "" && tokens + cost > maxTokens) {
+      out.push(current);
+      current = "";
+      tokens = 0;
+    }
+    current += char;
+    tokens += cost;
+  }
+  if (current !== "") out.push(current);
+  return out;
+}
+function splitOversizedBlock(text, maxTokens = THINK_MAX_INPUT_TOKENS) {
+  if (estimateTokens(text) <= maxTokens) return [text];
+  let chunks = splitKeepingSeparator(text, /(\n{2,})/);
+  if (chunks.length <= 1) chunks = splitKeepingSeparator(text, /(\n)/);
+  if (chunks.length <= 1) chunks = sentenceChunks(text);
+  const out = [];
+  let current = "";
+  for (const chunk of chunks) {
+    if (estimateTokens(chunk) > maxTokens) {
+      if (current !== "") {
+        out.push(current);
+        current = "";
+      }
+      out.push(...hardSlice(chunk, maxTokens));
+      continue;
+    }
+    if (current !== "" && estimateTokens(current + chunk) > maxTokens) {
+      out.push(current);
+      current = "";
+    }
+    current += chunk;
+  }
+  if (current !== "") out.push(current);
+  return out;
+}
+function packPieces(pieces, maxTokens = THINK_MAX_INPUT_TOKENS) {
+  const batches = [];
+  let current = [];
+  let tokens = 0;
+  for (const piece of pieces) {
+    const cost = estimateTokens(piece.text);
+    if (current.length > 0 && tokens + cost > maxTokens) {
+      batches.push(current);
+      current = [];
+      tokens = 0;
+    }
+    current.push(piece);
+    tokens += cost;
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+function createThinkBatchFormat() {
+  const id = randomTokenId();
+  return {
+    id,
+    token: (index) => `\u27EA${id}${index}\u27EB`
+  };
+}
+var BATCH_TOKEN_PATTERN_SOURCE = "\u27EA([a-z]{4})(\\d+)\u27EB";
+function buildBatchPayload(pieces, format) {
+  return pieces.map((text, index) => `${format.token(index)}
+${text}`).join("\n\n");
+}
+function splitBatchTranslation(translated, format, count) {
+  const pattern2 = new RegExp(BATCH_TOKEN_PATTERN_SOURCE, "gu");
+  const found = [];
+  let match;
+  while ((match = pattern2.exec(translated)) !== null) {
+    if (match[1].toLowerCase() !== format.id.toLowerCase()) return null;
+    const index = Number.parseInt(match[2] ?? "", 10);
+    if (Number.isNaN(index)) return null;
+    found.push({ index, start: match.index, end: match.index + match[0].length });
+  }
+  if (found.length !== count) return null;
+  const parts = [];
+  for (let index = 0; index < count; index++) {
+    const entry = found[index];
+    if (entry.index !== index) return null;
+    const next = found[index + 1];
+    const body = translated.slice(entry.end, next === void 0 ? translated.length : next.start).trim();
+    if (body === "") return null;
+    parts.push(body);
+  }
+  return parts;
+}
+function hasThinkBatchResidue(text) {
+  return new RegExp(BATCH_TOKEN_PATTERN_SOURCE, "u").test(text);
+}
+
 // src/server/dispatcher.ts
+function thinkPieceKey(piece) {
+  return `${piece.block}:${piece.index}`;
+}
 var TranslationDispatcher = class {
   configManager;
   cache;
+  /** 思考正文译文的独立缓存池，与工具标题的池互不挤占。 */
+  thinkCache;
   credentials;
   masking = new ContentMaskingPipeline();
   adapters = /* @__PURE__ */ new Map();
@@ -1493,9 +1715,12 @@ var TranslationDispatcher = class {
   inFlightMap = /* @__PURE__ */ new Map();
   activeCount = 0;
   queue = [];
-  constructor(configManager, cache, credentials) {
+  /** 思考链请求的串行队列尾，保证同时最多一个在途请求。 */
+  thinkTail = Promise.resolve();
+  constructor(configManager, cache, credentials, thinkCache = new LruDiskCache(THINK_CACHE_ENTRIES, "think-cache.json")) {
     this.configManager = configManager;
     this.cache = cache;
+    this.thinkCache = thinkCache;
     this.credentials = credentials ?? { getApiKey: () => "" };
     this.registerAdapter(new OpenAiCompatibleAdapter(this.credentials));
     this.registerAdapter(new BingWebAdapter());
@@ -1558,7 +1783,8 @@ var TranslationDispatcher = class {
         return inFlight;
       }
     }
-    const { maskedText, unmask } = this.masking.mask(text);
+    const { maskedText, unmask, legacyFragments } = this.masking.mask(text);
+    const documentedLegacy = new Set(legacyFragments.map((fragment) => fragment.toLowerCase()));
     const taskPromise = this.enqueueTask(async () => {
       const currentConfig = this.configManager.getConfig();
       const channels = this.computeChannels(currentConfig);
@@ -1580,10 +1806,13 @@ var TranslationDispatcher = class {
           const cleaned = translatedMasked?.trim();
           if (cleaned && cleaned.length > 0) {
             const finalTranslated = unmask(cleaned);
-            if (isMaskLeakAgainst(text, finalTranslated)) {
+            const legacyLeftovers = findLegacyMaskTokens(finalTranslated).filter(
+              (fragment) => !documentedLegacy.has(fragment.toLowerCase())
+            );
+            if (hasMaskResidue(finalTranslated) || legacyLeftovers.length > 0) {
               this.recordFailure(chId);
               console.warn(
-                `[dsh-chat-translate] channel ${chId} leaked a mask placeholder, discarding its result | text: ${text.slice(0, 60)}`
+                `[dsh-chat-translate] channel ${chId} left a mask placeholder in the translation, discarding its result | text: ${text.slice(0, 60)}`
               );
               continue;
             }
@@ -1602,8 +1831,9 @@ var TranslationDispatcher = class {
           );
         } catch (err) {
           this.recordFailure(chId);
+          const detail = err instanceof MaskRestoreError ? ` (protected fragments expected ${err.expectedCount}, restored ${err.foundCount})` : "";
           console.warn(
-            `[dsh-chat-translate] channel ${chId} failed: ${describeError(err)} | text: ${text.slice(0, 60)}`
+            `[dsh-chat-translate] channel ${chId} failed: ${describeError(err)}${detail} | text: ${text.slice(0, 60)}`
           );
         }
       }
@@ -1620,6 +1850,176 @@ var TranslationDispatcher = class {
       }
     }
   }
+  /**
+   * 翻译思考正文的块。整条链路与工具标题翻译分离：只走 AI 通道、独立串行
+   * 队列、独立超时、独立缓存池，Bing 从不参与。
+   *
+   * 每个块先按输入上限切成片段，再各自掩码、相邻片段打包成一个请求；整批
+   * 失败时退回逐片段单发，仍失败的片段保留原文。块内任一片段失败即整块不译，
+   * 避免半中半英的段落。
+   */
+  async translateThinkBlocks(blocks) {
+    const results = blocks.map((original) => ({
+      original,
+      translated: original,
+      ok: false,
+      cached: false,
+      channel: "none"
+    }));
+    const config = this.configManager.getConfig();
+    if (!config.enabled || !config.thinkEnabled) return results;
+    const adapter = this.adapters.get("openai");
+    if (!adapter || !adapter.isAvailable(config) || this.isChannelCoolingDown("openai")) {
+      return results;
+    }
+    const pieces = [];
+    for (let block = 0; block < blocks.length; block++) {
+      const text = (blocks[block] ?? "").trim();
+      if (!text) continue;
+      const cached = this.thinkCache.get(text.toLowerCase());
+      if (cached) {
+        results[block] = {
+          original: blocks[block],
+          translated: cached,
+          ok: true,
+          cached: true,
+          channel: "cache"
+        };
+        continue;
+      }
+      for (const [index, part] of splitOversizedBlock(text).entries()) {
+        const mask = this.masking.mask(part);
+        pieces.push({
+          block,
+          index,
+          text: mask.maskedText,
+          mask,
+          legacy: new Set(mask.legacyFragments.map((fragment) => fragment.toLowerCase()))
+        });
+      }
+    }
+    const translated = /* @__PURE__ */ new Map();
+    for (const batch of packPieces(pieces)) {
+      const outcome = await this.runThinkSerial(
+        () => this.translateThinkBatch(adapter, batch, config)
+      );
+      for (const [key, value] of outcome) translated.set(key, value);
+    }
+    const totals = /* @__PURE__ */ new Map();
+    for (const piece of pieces) totals.set(piece.block, (totals.get(piece.block) ?? 0) + 1);
+    for (const [block, total] of totals) {
+      const parts = [];
+      let complete = true;
+      for (let index = 0; index < total; index++) {
+        const part = translated.get(`${block}:${index}`);
+        if (part === void 0) {
+          complete = false;
+          break;
+        }
+        parts.push(part);
+      }
+      if (!complete) continue;
+      const original = blocks[block];
+      const finalText = parts.join("");
+      this.thinkCache.set(original.trim().toLowerCase(), finalText);
+      results[block] = { original, translated: finalText, ok: true, cached: false, channel: "openai" };
+    }
+    return results;
+  }
+  /**
+   * 一整批一次请求；失败则该批逐片段单发重试一次，仍失败的片段直接放弃
+   * （保留原文），不在界面上留提示。
+   */
+  async translateThinkBatch(adapter, batch, config) {
+    try {
+      return await this.requestThinkBatch(adapter, batch, config);
+    } catch (err) {
+      console.warn(
+        `[dsh-chat-translate] think batch of ${batch.length} failed, retrying per block: ${describeError(err)}`
+      );
+    }
+    const out = /* @__PURE__ */ new Map();
+    for (const piece of batch) {
+      try {
+        for (const [key, value] of await this.requestThinkBatch(adapter, [piece], config)) {
+          out.set(key, value);
+        }
+      } catch (err) {
+        console.warn(
+          `[dsh-chat-translate] think block ${piece.block} #${piece.index} failed, keeping the original: ${describeError(err)}`
+        );
+      }
+    }
+    return out;
+  }
+  /** 发出一次思考链请求并把结果还原成每个片段的最终译文。 */
+  async requestThinkBatch(adapter, batch, config) {
+    const timeout = config.thinkTimeoutMs || 6e5;
+    const abortCtrl = new AbortController();
+    const timer = setTimeout(() => abortCtrl.abort(), timeout);
+    let answers;
+    try {
+      if (batch.length === 1) {
+        answers = [
+          await adapter.translate(batch[0].text, abortCtrl.signal, config, {
+            maxTokens: THINK_MAX_OUTPUT_TOKENS,
+            mode: "plain"
+          })
+        ];
+      } else {
+        const format = createThinkBatchFormat();
+        const answer = await adapter.translate(
+          buildBatchPayload(batch.map((piece) => piece.text), format),
+          abortCtrl.signal,
+          config,
+          { maxTokens: THINK_MAX_OUTPUT_TOKENS, mode: "blocks" }
+        );
+        const parts = splitBatchTranslation(answer, format, batch.length);
+        if (parts === null) {
+          throw new Error("think block markers did not survive the translation");
+        }
+        answers = parts;
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+    const out = /* @__PURE__ */ new Map();
+    batch.forEach((piece, index) => {
+      const answer = (answers[index] ?? "").trim();
+      if (!answer) {
+        throw new Error(`think block ${piece.block} #${piece.index} came back empty`);
+      }
+      if (hasThinkBatchResidue(answer)) {
+        throw new Error("think translation left a block marker behind");
+      }
+      const finalText = piece.mask.unmask(answer);
+      const leftovers = findLegacyMaskTokens(finalText).filter(
+        (fragment) => !piece.legacy.has(fragment.toLowerCase())
+      );
+      if (hasMaskResidue(finalText) || leftovers.length > 0) {
+        throw new Error("think translation left a mask placeholder behind");
+      }
+      out.set(thinkPieceKey(piece), finalText);
+    });
+    return out;
+  }
+  /** 串行执行器：同时最多一个在途请求，与工具标题的并发池完全独立。 */
+  runThinkSerial(task) {
+    const next = this.thinkTail.then(task, task);
+    this.thinkTail = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  /**
+   * 只读判断某通道是否还在熔断冷却期。思考链翻译只借用这个判断避开已经
+   * 出问题的服务，不改动熔断状态本身（那是工具标题通道的记账）。
+   */
+  isChannelCoolingDown(channelId) {
+    const state = this.circuitStates.get(channelId);
+    return state !== void 0 && state.state === "open" && Date.now() < state.openUntil;
+  }
   async testChannel(channelId) {
     const adapter = this.adapters.get(channelId);
     const config = this.configManager.getConfig();
@@ -1736,50 +2136,33 @@ var TranslationDispatcher = class {
 };
 
 // src/server/router.ts
-var MAX_BODY_BYTES = 1024 * 1024;
-function sendJson(res, status, body) {
-  const json = JSON.stringify(body);
-  res.writeHead(status, {
-    "Content-Type": "application/json; charset=utf-8",
-    "Content-Length": Buffer.byteLength(json)
+var TRANSLATE_ROUTE_PATH = "/api/dsh-chat-translate/translate";
+var TEST_CHANNEL_ROUTE_PATH = "/api/dsh-chat-translate/test-channel";
+var THINK_ROUTE_PATH = "/api/dsh-chat-translate/translate-think";
+function sendJson(status, body) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "Content-Type": "application/json; charset=utf-8" }
   });
-  res.end(json);
 }
-function readBody(req) {
-  return new Promise((resolve3, reject) => {
-    const chunks = [];
-    let totalLength = 0;
-    req.on("data", (chunk) => {
-      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      totalLength += buf.length;
-      if (totalLength > MAX_BODY_BYTES) {
-        if (typeof req.destroy === "function") {
-          req.destroy();
-        }
-        reject(new Error("Request body exceeded maximum allowed size (1MB)"));
-        return;
-      }
-      chunks.push(buf);
-    });
-    req.on("end", () => resolve3(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
+async function readJson(request) {
+  try {
+    return { ok: true, value: await request.json() };
+  } catch {
+    return { ok: false, response: sendJson(400, { ok: false, error: "Invalid JSON body" }) };
+  }
 }
-function createHttpHandler(configManager, dispatcher) {
-  return async (req, res) => {
-    const url = new URL(req.url || "/", "http://localhost");
-    const pathParts = url.pathname.split("/").filter(Boolean);
-    const endpoint = pathParts[2] || "";
-    try {
-      if (endpoint === "translate" && req.method === "POST") {
-        const raw = await readBody(req);
-        let parsed;
-        try {
-          parsed = JSON.parse(raw || "{}");
-        } catch {
-          sendJson(res, 400, { ok: false, error: "Invalid JSON body" });
-          return;
-        }
+function createFetchRoutes(dispatcher, ready = Promise.resolve()) {
+  const translate = {
+    path: TRANSLATE_ROUTE_PATH,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      await ready;
+      try {
+        const body = await readJson(request);
+        if (!body.ok) return body.response;
+        const parsed = body.value;
         const rawTexts = parsed.texts !== void 0 ? parsed.texts : parsed.text;
         let texts = [];
         if (Array.isArray(rawTexts)) {
@@ -1789,45 +2172,68 @@ function createHttpHandler(configManager, dispatcher) {
         }
         const forceRefresh = Boolean(parsed.forceRefresh);
         if (texts.length === 0) {
-          sendJson(res, 200, { ok: true, results: [] });
-          return;
+          return sendJson(200, { ok: true, results: [] });
         }
         const results = await dispatcher.translateBatch(texts, forceRefresh);
-        sendJson(res, 200, { ok: true, results });
-        return;
+        return sendJson(200, { ok: true, results });
+      } catch (err) {
+        return sendJson(500, { ok: false, error: describeError(err) });
       }
-      if (endpoint === "test-channel" && req.method === "POST") {
-        const raw = await readBody(req);
-        let parsed;
-        try {
-          parsed = JSON.parse(raw || "{}");
-        } catch {
-          sendJson(res, 400, { ok: false, error: "Invalid JSON body" });
-          return;
+    }
+  };
+  const think = {
+    path: THINK_ROUTE_PATH,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      await ready;
+      try {
+        const body = await readJson(request);
+        if (!body.ok) return body.response;
+        const rawBlocks = body.value?.blocks;
+        const blocks = Array.isArray(rawBlocks) ? rawBlocks.filter((block) => typeof block === "string") : [];
+        if (blocks.length === 0) {
+          return sendJson(200, { ok: true, results: [] });
         }
-        const channelId = typeof parsed.channel === "string" ? parsed.channel : "";
+        const results = await dispatcher.translateThinkBlocks(blocks);
+        return sendJson(200, { ok: true, results });
+      } catch (err) {
+        return sendJson(500, { ok: false, error: describeError(err) });
+      }
+    }
+  };
+  const testChannel = {
+    path: TEST_CHANNEL_ROUTE_PATH,
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      await ready;
+      try {
+        const body = await readJson(request);
+        if (!body.ok) return body.response;
+        const channelId = typeof body.value.channel === "string" ? body.value.channel : "";
         const result = await dispatcher.testChannel(channelId);
-        sendJson(res, 200, result);
-        return;
+        return sendJson(200, result);
+      } catch (err) {
+        return sendJson(500, { ok: false, error: describeError(err) });
       }
-      sendJson(res, 404, { ok: false, error: "Endpoint not found" });
-    } catch (err) {
-      const status = err?.message?.includes("exceeded maximum allowed size") ? 413 : 500;
-      sendJson(res, status, { ok: false, error: describeError(err) });
     }
   };
+  return [translate, think, testChannel];
 }
 
 // src/index.ts
 var name = "dsh-chat-translate";
-var inject = ["webServer", "settings", "credentials"];
+var inject = ["settings", "credentials"];
 var CONFIG_SCHEMA = Schema.object({
   enabled: Schema.boolean().default(DEFAULT_CONFIG.enabled),
   concurrency: Schema.number().min(1).max(MAX_CONCURRENCY).default(DEFAULT_CONFIG.concurrency),
   timeoutMs: Schema.number().min(500).max(1e4).default(DEFAULT_CONFIG.timeoutMs),
   aiTimeoutMs: Schema.number().min(AI_TIMEOUT_MIN).max(AI_TIMEOUT_MAX).default(DEFAULT_CONFIG.aiTimeoutMs),
+  thinkTimeoutMs: Schema.number().min(THINK_TIMEOUT_MIN).max(THINK_TIMEOUT_MAX).default(DEFAULT_CONFIG.thinkTimeoutMs),
   aiEnabled: Schema.boolean().default(DEFAULT_CONFIG.aiEnabled),
   bingEnabled: Schema.boolean().default(DEFAULT_CONFIG.bingEnabled),
+  thinkEnabled: Schema.boolean().default(DEFAULT_CONFIG.thinkEnabled),
   baseUrl: Schema.string().default(DEFAULT_CONFIG.baseUrl),
   model: Schema.string().default(DEFAULT_CONFIG.model),
   targetLang: Schema.string().default(DEFAULT_CONFIG.targetLang)
@@ -1836,11 +2242,13 @@ function apply(ctx) {
   const credentials = new CredentialsReader(ctx.credentials);
   const configManager = new ConfigManager(ctx.settings.register(SETTINGS_NAMESPACE, CONFIG_SCHEMA), credentials);
   const cache = new LruDiskCache(1e3);
-  const dispatcher = new TranslationDispatcher(configManager, cache, credentials);
+  const thinkCache = new LruDiskCache(THINK_CACHE_ENTRIES, "think-cache.json");
+  const dispatcher = new TranslationDispatcher(configManager, cache, credentials, thinkCache);
   const legacyConfigPath = dshHomePath("dsh-chat-translate-config.json");
   const initPromise = Promise.all([
     credentials.init(),
     cache.init(),
+    thinkCache.init(),
     migrateLegacyConfigFile(ctx.settings, legacyConfigPath)
   ]).catch((err) => {
     console.warn("[dsh-chat-translate] Initialization error:", err);
@@ -1850,32 +2258,16 @@ function apply(ctx) {
       void credentials.refresh();
     }
   });
-  const webServer = ctx.webServer || (ctx.get ? ctx.get("webServer") : null);
-  if (webServer && typeof webServer.register === "function") {
-    const rawHandler = createHttpHandler(configManager, dispatcher);
-    const handler = async (req, res) => {
-      await initPromise;
-      return rawHandler(req, res);
-    };
-    ctx.effect(
-      () => {
-        const unregister = webServer.register({
-          kind: "prefix",
-          path: "/api/dsh-chat-translate",
-          handler
-        });
-        return () => {
-          if (typeof unregister === "function") {
-            unregister();
-          }
-          cache.dispose().catch((err) => {
-            console.warn("[dsh-chat-translate] Dispose cache error:", err);
-          });
-        };
-      },
-      "dsh-chat-translate: translation API routes"
+  ctx.inject(["connection"], (connectionCtx) => {
+    const disposers = createFetchRoutes(dispatcher, initPromise).map(
+      (route) => connectionCtx.connection.fetch.register(route)
     );
-  }
+    return () => {
+      void Promise.all(disposers.map((dispose) => dispose())).then(() => Promise.all([cache.dispose(), thinkCache.dispose()])).catch((err) => {
+        console.warn("[dsh-chat-translate] Dispose translation routes error:", err);
+      });
+    };
+  });
 }
 export {
   apply,