dsh-input-assistant 0.1.3 → 0.1.4

package/lib/core.js

@@ -5,6 +5,7 @@ var DEFAULT_CONFIG = Object.freeze({
   optimizationStrength: "standard",
   nextEnabled: true,
   completionEnabled: true,
+  predictionDetail: "standard",
   displayMode: "ghost",
   debounceMs: 600,
   minIntervalMs: 2e3,
@@ -33,8 +34,8 @@ var numeric = {
   minIntervalMs: [500, 3e4],
   maxHistoryChars: [1e3, 64e3],
   maxDraftChars: [100, 32e3],
-  maxNextChars: [20, 300],
-  maxCompletionChars: [10, 200],
+  maxNextChars: [20, 1e3],
+  maxCompletionChars: [10, 500],
   optimizeTimeoutMs: [1e3, 12e4],
   suggestionTimeoutMs: [1e3, 6e4]
 };
@@ -46,6 +47,7 @@ function validate(config) {
   }
   if (!["ghost", "panel"].includes(config.displayMode)) throw new AssistantError("CONFIG", "\u663E\u793A\u65B9\u5F0F\u5FC5\u987B\u662F ghost \u6216 panel");
   if (!["light", "standard", "deep"].includes(config.optimizationStrength)) throw new AssistantError("CONFIG", "\u4F18\u5316\u5F3A\u5EA6\u5FC5\u987B\u662F light\u3001standard \u6216 deep");
+  if (!["concise", "standard", "detailed"].includes(config.predictionDetail)) throw new AssistantError("CONFIG", "\u9884\u6D4B\u8BE6\u7565\u5EA6\u5FC5\u987B\u662F concise\u3001standard \u6216 detailed");
   for (const [key, [min, max]] of Object.entries(numeric)) {
     const value = config[key];
     if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
@@ -67,6 +69,7 @@ function resolveStoredConfig(input) {
   const record = input && typeof input === "object" && !Array.isArray(input) ? input : {};
   const config = { ...DEFAULT_CONFIG };
   for (const key of Object.keys(DEFAULT_CONFIG)) {
+    if (key === "provider" || key === "model") continue;
     if (!(key in record)) continue;
     const value = record[key];
     const candidate = { ...DEFAULT_CONFIG, [key]: value };
@@ -77,9 +80,11 @@ function resolveStoredConfig(input) {
     }
     config[key] = typeof value === "string" ? value.trim() : value;
   }
-  if (Boolean(config.provider) !== Boolean(config.model)) {
-    config.provider = "";
-    config.model = "";
+  try {
+    const route = validate({ ...DEFAULT_CONFIG, provider: record.provider ?? "", model: record.model ?? "" });
+    config.provider = route.provider;
+    config.model = route.model;
+  } catch {
   }
   return config;
 }
@@ -117,7 +122,7 @@ function buildContext(history, budget = 16e3) {
 }
 
 // src/core/protection.ts
-var FILE_EXTENSIONS = [
+var FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "json",
   "jsonc",
   "json5",
@@ -207,8 +212,8 @@ var FILE_EXTENSIONS = [
   "stylelintrc",
   "babelrc",
   "browserslistrc"
-].join("|");
-var NAMED_FILES = [
+]);
+var NAMED_FILES = /* @__PURE__ */ new Set([
   "LICENSE",
   "LICENCE",
   "README",
@@ -225,28 +230,193 @@ var NAMED_FILES = [
   "Vagrantfile",
   "Jenkinsfile",
   "Brewfile"
-].join("|");
-var pathSegment = "[\\p{L}\\p{N}\\p{M}_.@+~-]";
-function protectText(text, locked = []) {
+]);
+var DOTFILES = [
+  ".env",
+  ".npmrc",
+  ".nvmrc",
+  ".editorconfig",
+  ".gitignore",
+  ".gitattributes",
+  ".gitmodules",
+  ".prettierrc",
+  ".eslintrc",
+  ".stylelintrc",
+  ".babelrc",
+  ".browserslistrc"
+];
+var candidatePattern = /[\p{L}\p{N}\p{M}_.@+~\\/-]+/uy;
+var cjk = "[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}\\p{Script=Hangul}]";
+var cjkCharacter = new RegExp(cjk, "u");
+var candidateEnding = new RegExp(`(?:\\.[A-Za-z][A-Za-z0-9]{0,11}|${[...NAMED_FILES].join("|")})(?=${cjk}|$)`, "gu");
+function knownFile(value) {
+  const dot = value.lastIndexOf(".");
+  return NAMED_FILES.has(value) || DOTFILES.some((name) => value === name || value.startsWith(name + ".")) || dot > 0 && FILE_EXTENSIONS.has(value.slice(dot + 1).toLowerCase());
+}
+function pathOrFile(value) {
+  const slash = Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\"));
+  if (slash < 0) return knownFile(value);
+  if (/^(?:\.{1,2}[\\/]|[\\/])/.test(value)) return value.length > slash + 1 || slash > 0;
+  const tail = value.slice(slash + 1), dot = tail.lastIndexOf(".");
+  if (dot >= 0 && /^[A-Za-z][A-Za-z0-9]{0,11}$/.test(tail.slice(dot + 1))) return true;
+  let separators = 0;
+  for (const char of value) if (char === "/" || char === "\\") separators++;
+  return separators >= 2;
+}
+function literalStart(value) {
+  const slash = value.search(/[\\/]/);
+  const first = slash < 0 ? value : value.slice(0, slash);
+  if (slash >= 0) {
+    const relative = first.match(/(?:\.{1,2}|~)$/);
+    if (relative) return relative.index;
+  }
+  const dot = first.indexOf(".");
+  const stem = dot < 0 ? first : first.slice(0, dot);
+  let start = 0, previous = "", offset = 0;
+  for (const char of stem) {
+    if (cjkCharacter.test(previous) && /[A-Za-z0-9_@+~-]/.test(char)) start = offset;
+    previous = char;
+    offset += char.length;
+  }
+  if (!start && dot > 0 && DOTFILES.some((name) => first.slice(dot) === name || first.slice(dot).startsWith(name + ".")) && Array.from(stem).every((char) => cjkCharacter.test(char))) return dot;
+  return start;
+}
+function candidateRanges(value, base) {
+  const ranges = [];
+  let cursor = 0;
+  candidateEnding.lastIndex = 0;
+  for (const ending of value.matchAll(candidateEnding)) {
+    const end = ending.index + ending[0].length;
+    let next = end;
+    while (next < value.length) {
+      const char = String.fromCodePoint(value.codePointAt(next));
+      if (!cjkCharacter.test(char)) break;
+      next += char.length;
+    }
+    if (next > end && /[\\/]/.test(value[next] ?? "")) continue;
+    const portion = value.slice(cursor, end);
+    const start = cursor + literalStart(portion);
+    if (pathOrFile(value.slice(start, end))) ranges.push({ start: base + start, end: base + end });
+    cursor = end;
+  }
+  if (cursor < value.length && /[.\\/]/.test(value.slice(cursor))) {
+    const portion = value.slice(cursor);
+    const start = cursor + literalStart(portion);
+    let end = value.length;
+    const tailStart = Math.max(start, Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 1);
+    const tail = value.slice(tailStart), boundary = tail.search(cjkCharacter);
+    if (tailStart >= start && boundary > 0 && /^[A-Za-z0-9_@+~.-]/.test(tail)) end = tailStart + boundary;
+    if (pathOrFile(value.slice(start, end))) ranges.push({ start: base + start, end: base + end });
+  }
+  return ranges;
+}
+function urlEnd(text, start) {
+  let end = start, parentheses = 0, brackets = 0;
+  while (end < text.length) {
+    const char = text[end];
+    if (/[\s<>"'`，。；;）]/.test(char)) break;
+    if (char === "(") parentheses++;
+    else if (char === ")") {
+      if (!parentheses) break;
+      parentheses--;
+    } else if (char === "[") brackets++;
+    else if (char === "]") {
+      if (!brackets) break;
+      brackets--;
+    }
+    end++;
+  }
+  while (end > start && /[.,!]/.test(text[end - 1])) end--;
+  return end;
+}
+function windowsPathEnd(text, start) {
+  const quote = text[start - 1];
+  if (quote === '"' || quote === "'") {
+    const closing = text.indexOf(quote, start);
+    if (closing >= 0 && !/[\r\n]/.test(text.slice(start, closing))) return closing;
+  }
+  let end = start + 3;
+  while (end < text.length && !/[\r\n<>"'`，。；;）)\]！？!?：:]/.test(text[end])) end++;
+  while (end > start && /[ \t]/.test(text[end - 1])) end--;
+  const value = text.slice(start, end);
+  const tailStart = Math.max(value.lastIndexOf("/"), value.lastIndexOf("\\")) + 1;
+  const tail = value.slice(tailStart);
+  const dotfile = DOTFILES.some((name) => tail.startsWith(name) && /[. \t]/.test(tail[name.length] ?? ""));
+  let dot = -1;
+  for (let i = 0; i < tail.length; i++) {
+    if (tail[i] === ".") dot = i;
+    if (/[ \t]/.test(tail[i]) && (dotfile || dot >= 0 && i - dot <= 13 && FILE_EXTENSIONS.has(tail.slice(dot + 1, i).toLowerCase()) || i <= 20 && NAMED_FILES.has(tail.slice(0, i)))) return start + tailStart + i;
+  }
+  return end;
+}
+function automaticRanges(text) {
   const ranges = [];
-  const patterns = [
-    /```[^]*?(?:```|$)/g,
-    /~~~[^]*?(?:~~~|$)/g,
-    /`[^`\n]+`/g,
-    /https?:\/\/[^\s<>"'）)\]，。；;]+/g,
-    /[A-Za-z]:[\\/][^\s<>"'，。；;）)\]]+/g,
-    /(?:\.{1,2}[\\/]|\/(?:[\p{L}\p{N}\p{M}_.-]+\/)+)[\p{L}\p{N}\p{M}_./\\@+-]+/gu,
-    // Relative path carrying an extension: `src/index.ts`, `docs/validation.md`.
-    // Requires at least one separator so plain prose words stay untouched.
-    new RegExp(`(?:${pathSegment}+\\/)+${pathSegment}*\\.[A-Za-z][A-Za-z0-9]{0,11}`, "gu"),
-    // Deep relative path without an extension: `src/core/generation`.
-    new RegExp(`(?:${pathSegment}+\\/){2,}${pathSegment}+`, "gu"),
-    // Bare file name with a known extension: `package.json`, `README.md`.
-    new RegExp(`${pathSegment}+\\.(?:${FILE_EXTENSIONS})(?![A-Za-z0-9_])`, "giu"),
-    // Well-known extensionless file names.
-    new RegExp(`(?<![A-Za-z0-9_])(?:${NAMED_FILES})(?![A-Za-z0-9_])`, "g")
-  ];
-  for (const re of patterns) for (const m of text.matchAll(re)) ranges.push({ start: m.index, end: m.index + m[0].length });
+  let cursor = 0;
+  while (cursor < text.length) {
+    const start = cursor;
+    const fence = text.startsWith("```", cursor) ? "```" : text.startsWith("~~~", cursor) ? "~~~" : null;
+    if (fence) {
+      const closing = text.indexOf(fence, cursor + 3);
+      cursor = closing < 0 ? text.length : closing + 3;
+      ranges.push({ start, end: cursor });
+      continue;
+    }
+    if (text[cursor] === "`") {
+      let end = cursor + 1;
+      while (end < text.length && text[end] !== "`" && text[end] !== "\n") end++;
+      if (text[end] === "`" && end > cursor + 1) {
+        cursor = end + 1;
+        ranges.push({ start, end: cursor });
+        continue;
+      }
+    }
+    if (text[cursor] === '"' || text[cursor] === "'") {
+      const closing = text.indexOf(text[cursor], cursor + 1);
+      if (closing >= 0) {
+        const literal = text.slice(cursor + 1, closing);
+        if (!/[\r\n]/.test(literal) && (pathOrFile(literal) || /^[A-Za-z]:[\\/]/.test(literal))) {
+          ranges.push({ start: cursor + 1, end: closing });
+          cursor = closing + 1;
+          continue;
+        }
+      }
+    }
+    const scheme = text.slice(cursor, cursor + 8).toLowerCase();
+    if (scheme.startsWith("https://") || scheme.startsWith("http://")) {
+      cursor = urlEnd(text, cursor);
+      ranges.push({ start, end: cursor });
+      continue;
+    }
+    if (/[A-Za-z]/.test(text[cursor]) && text[cursor + 1] === ":" && /[\\/]/.test(text[cursor + 2] ?? "")) {
+      cursor = windowsPathEnd(text, cursor);
+      ranges.push({ start, end: cursor });
+      continue;
+    }
+    candidatePattern.lastIndex = cursor;
+    const match = candidatePattern.exec(text);
+    if (match) {
+      cursor = candidatePattern.lastIndex;
+      const fenceOffset = match[0].indexOf("~~~");
+      if (fenceOffset >= 0) cursor = start + fenceOffset;
+      else if (text[cursor] === ":") {
+        if (text.startsWith("//", cursor + 1)) {
+          const ending = text.slice(Math.max(start, cursor - 5), cursor).toLowerCase();
+          if (ending.endsWith("https")) cursor -= 5;
+          else if (ending.endsWith("http")) cursor -= 4;
+          else if (/[A-Za-z]/.test(text[cursor - 1] ?? "")) cursor--;
+        } else if (/[\\/]/.test(text[cursor + 1] ?? "") && /[A-Za-z]/.test(text[cursor - 1] ?? "")) cursor--;
+      }
+      if (cursor === start) continue;
+      let end = cursor;
+      if (!/[\\/]\.{1,2}$/.test(text.slice(start, cursor))) while (end > start && text[end - 1] === ".") end--;
+      const value = text.slice(start, end);
+      if (value) ranges.push(...candidateRanges(value, start));
+    } else cursor++;
+  }
+  return ranges;
+}
+function protectText(text, locked = []) {
+  const ranges = automaticRanges(text);
   for (const literal of locked) {
     if (typeof literal !== "string" || !literal.length || !text.includes(literal)) throw new AssistantError("LOCK_SCOPE", "\u9501\u5B9A\u7247\u6BB5\u5DF2\u53D8\u5316\u6216\u4E0D\u5728\u672C\u6B21\u4F18\u5316\u8303\u56F4\u5185");
     let start = text.indexOf(literal);
@@ -262,8 +432,14 @@ function protectText(text, locked = []) {
     if (prev && r.start < prev.end) prev.end = Math.max(prev.end, r.end);
     else merged.push({ ...r });
   }
-  let prefix = "DSH_KEEP_";
-  while (text.includes(prefix)) prefix = "_" + prefix;
+  let longestPrefix = -1, occurrence = text.indexOf("DSH_KEEP_");
+  while (occurrence >= 0) {
+    let start = occurrence;
+    while (start > 0 && text[start - 1] === "_") start--;
+    longestPrefix = Math.max(longestPrefix, occurrence - start);
+    occurrence = text.indexOf("DSH_KEEP_", occurrence + 9);
+  }
+  const prefix = "_".repeat(longestPrefix + 1) + "DSH_KEEP_";
   const fragments = [];
   let cursor = 0, masked = "";
   for (const r of merged) {
@@ -276,19 +452,20 @@ function protectText(text, locked = []) {
   return { original: text, masked: masked + text.slice(cursor), fragments };
 }
 function restoreProtected(output, protectedText) {
-  let remaining = output;
-  for (const { token } of protectedText.fragments) {
-    if (remaining.split(token).length !== 2) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u672A\u5B8C\u6574\u4FDD\u7559\u9501\u5B9A\u5185\u5BB9\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
-    remaining = remaining.replace(token, "");
-  }
-  for (const marker of remaining.match(/⟪_*DSH_KEEP_\d+⟫/gu) ?? []) {
-    if (!protectedText.original.includes(marker)) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u5305\u542B\u65E0\u6548\u7684\u4FDD\u62A4\u6807\u8BB0\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
-  }
-  let restored = output;
-  for (const { token, original } of protectedText.fragments) {
-    if (restored.split(token).length !== 2) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u672A\u5B8C\u6574\u4FDD\u7559\u9501\u5B9A\u5185\u5BB9\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
-    restored = restored.replace(token, () => original);
-  }
+  const fragments = new Map(protectedText.fragments.map((fragment) => [fragment.token, fragment.original]));
+  const existing = new Set(protectedText.original.match(/⟪_*DSH_KEEP_\d+⟫/gu) ?? []);
+  const seen = /* @__PURE__ */ new Set();
+  const restored = output.replace(/⟪_*DSH_KEEP_\d+⟫/gu, (token) => {
+    const original = fragments.get(token);
+    if (original === void 0) {
+      if (!existing.has(token)) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u5305\u542B\u65E0\u6548\u7684\u4FDD\u62A4\u6807\u8BB0\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
+      return token;
+    }
+    if (seen.has(token)) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u672A\u5B8C\u6574\u4FDD\u7559\u9501\u5B9A\u5185\u5BB9\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
+    seen.add(token);
+    return original;
+  });
+  if (seen.size !== fragments.size) throw new AssistantError("PROTECTION", "\u751F\u6210\u7ED3\u679C\u672A\u5B8C\u6574\u4FDD\u7559\u9501\u5B9A\u5185\u5BB9\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
   return restored;
 }
 
@@ -309,6 +486,13 @@ function prepareGeneration(request, history, config) {
   if (charCount(target) > config.maxDraftChars) throw new AssistantError("TOO_LONG", `\u672C\u6B21\u6587\u672C\u8D85\u8FC7 ${config.maxDraftChars} \u5B57\u7B26\uFF0C\u8BF7\u9009\u4E2D\u8F83\u77ED\u7247\u6BB5\u4F18\u5316`);
   if (request.operation === "optimize" && !target.trim()) throw new AssistantError("EMPTY", "\u8BF7\u5148\u8F93\u5165\u6216\u9009\u4E2D\u9700\u8981\u4F18\u5316\u7684\u6587\u5B57");
   if (request.operation === "complete" && !request.draft.trim()) throw new AssistantError("EMPTY", "\u6CA1\u6709\u53EF\u7EED\u5199\u7684\u8349\u7A3F");
+  const detail = config.predictionDetail;
+  const suggestionCap = request.operation === "next" ? config.maxNextChars : config.maxCompletionChars;
+  const detailGuidance = {
+    concise: "Detail level: CONCISE. Prefer one brief sentence or phrase. Do not add scope merely to fill the character budget.",
+    standard: "Detail level: STANDARD. Use a natural, complete expression with only the detail needed for the current intent.",
+    detailed: "Detail level: DETAILED. Explain only already-supported intent more fully; short paragraphs or a structured list are allowed when useful. There is no minimum length. Never add tasks, constraints, permissions, deliverables, or commitments merely to make the message longer."
+  }[detail];
   let system = common, protection = null;
   if (request.operation === "optimize") {
     protection = protectText(target, request.lockedFragments);
@@ -333,18 +517,22 @@ function prepareGeneration(request, history, config) {
       "Consider answering the latest question, a natural follow-up question, correcting a misunderstanding, or proceeding with an explicitly requested unfinished step.",
       "A question or correction is allowed when supported. Do not automatically propose commits, pushing, testing, or new features just because code was produced.",
       `If no single continuation is well-supported, or the task is naturally finished, output ${NO_SUGGESTION}. Do not guess an unresolved choice.`,
-      `Return one short message of at most ${config.maxNextChars} characters.`,
+      `Return one message of at most ${suggestionCap} Unicode characters. This is a hard maximum, not a target or minimum.`,
+      detailGuidance,
+      detail === "detailed" ? "Internal line breaks are allowed for supported structure; do not add blank padding lines." : "Return a single line with no line breaks.",
       "Examples: user requested hit rate AND invalidation, only hit rate was explained -> \u518D\u89E3\u91CA\u4E00\u4E0B\u7F13\u5B58\u5931\u6548\u3002",
       "User said explanation only, assistant proposes file edits -> \u5148\u4E0D\u8981\u6539\u6587\u4EF6\uFF0C\u8BF7\u53EA\u89E3\u91CA\u539F\u56E0\u3002",
       `Assistant asks Redis or local cache, no preference in history -> ${NO_SUGGESTION}.`
     ].join("\n");
   } else {
     system += "\n" + [
-      "Complete the user's current draft by returning ONLY a short suffix to append exactly at its end.",
+      "Complete the user's current draft by returning ONLY a suffix to append exactly at its end.",
       "The draft is the strongest constraint. Do not repeat its prefix, rewrite existing text, introduce a new topic, or answer the question.",
       "Preserve necessary leading whitespace in the suffix. A complete message does not need an arbitrary extra requirement.",
       `If the intended continuation is uncertain or the draft is already complete, output ${NO_SUGGESTION}.`,
-      `Return at most ${config.maxCompletionChars} characters, with no explanation.`,
+      `Return at most ${suggestionCap} Unicode characters, with no explanation. This is a hard maximum, not a target or minimum.`,
+      detailGuidance,
+      detail === "detailed" ? "Line breaks are allowed only when they naturally continue the existing draft structure. Preserve a necessary leading line break, but do not start an unrelated list or task." : "Return a single line with no line breaks.",
       "Examples: draft \u8BF7\u89E3\u91CA\u8FD9\u6BB5\u4EE3\u7801\u7684\u65F6\u95F4 -> \u590D\u6742\u5EA6\u3002",
       `Draft Please explain the cause without editing files. -> ${NO_SUGGESTION}.`
     ].join("\n");
@@ -363,11 +551,46 @@ function prepareGeneration(request, history, config) {
     config,
     protection,
     timeoutMs: request.operation === "optimize" ? config.optimizeTimeoutMs : config.suggestionTimeoutMs,
-    maxOutputTokens: request.operation === "optimize" ? 8192 : request.operation === "next" ? 256 : 192
+    // A Unicode character may require several tokens, especially for CJK and
+    // emoji. Keep the transport budget large enough for the explicit text cap.
+    maxOutputTokens: request.operation === "optimize" ? 8192 : Math.max(request.operation === "next" ? 128 : 96, suggestionCap * 4 + 32)
   };
 }
+function hasUnpairedSurrogate(text) {
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = text.charCodeAt(++i);
+      if (!(next >= 56320 && next <= 57343)) return true;
+    } else if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function cleanOptimizationOutput(raw, prepared) {
+  let cleaned = raw.trim();
+  const original = prepared.protection.original.trim();
+  const masked = prepared.protection.masked.trim();
+  if (cleaned === masked) return cleaned;
+  const fence = cleaned.match(/^```(?:markdown|prompt|text)?\r?\n([\s\S]*?)\r?\n```$/i);
+  if (fence) cleaned = fence[1].trim();
+  const preamble = /^(?:(?:好的|好的，|已为您|根据您的要求|针对您的需求|我为您)?(?:优化|改写|整理|修改|调整)后的?(?:提示词|prompt|内容|表达|文本)?(?:如下|为)?[:：\s\n]+|Here(?:'s| is) (?:the |an )?(?:optimized|improved|rewritten) (?:prompt|version)[:：\s\n]+)/i;
+  const prefix = cleaned.match(preamble)?.[0];
+  if (prefix && !original.toLowerCase().startsWith(prefix.trim().toLowerCase())) cleaned = cleaned.slice(prefix.length).trim();
+  for (const [start, end] of [['"', '"'], ["\u201C", "\u201D"], ["`", "`"]]) {
+    if (!cleaned.startsWith(start) || !cleaned.endsWith(end) || cleaned.length < 2) continue;
+    const inner = cleaned.slice(start.length, -end.length).trim();
+    const originalWrapped = masked.startsWith(start) && masked.endsWith(end);
+    if (!originalWrapped || inner.startsWith(start) && inner.endsWith(end)) cleaned = inner;
+    break;
+  }
+  return cleaned;
+}
 function finishGeneration(raw, prepared) {
   if (typeof raw !== "string") throw new AssistantError("OUTPUT", "\u6A21\u578B\u672A\u8FD4\u56DE\u6709\u6548\u6587\u5B57");
+  if (hasUnpairedSurrogate(raw)) {
+    if (prepared.operation === "optimize") throw new AssistantError("OUTPUT", "\u6A21\u578B\u8FD4\u56DE\u4E86\u4E0D\u5B8C\u6574\u5B57\u7B26\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
+    return null;
+  }
   const trimmed = raw.trim();
   if (!trimmed || trimmed === NO_SUGGESTION) {
     if (prepared.operation === "optimize") throw new AssistantError("EMPTY_OUTPUT", "\u6A21\u578B\u672A\u8FD4\u56DE\u4F18\u5316\u6587\u5B57\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
@@ -375,16 +598,20 @@ function finishGeneration(raw, prepared) {
   }
   if (prepared.operation === "optimize") {
     if (raw.includes(NO_SUGGESTION)) throw new AssistantError("OUTPUT", "\u6A21\u578B\u8F93\u51FA\u4E0D\u5B8C\u6574\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
-    const output = restoreProtected(trimmed, prepared.protection);
+    const cleaned = cleanOptimizationOutput(trimmed, prepared);
+    if (!cleaned.trim()) throw new AssistantError("EMPTY_OUTPUT", "\u6A21\u578B\u672A\u8FD4\u56DE\u4F18\u5316\u6587\u5B57\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
+    const output = restoreProtected(cleaned, prepared.protection);
+    if (hasUnpairedSurrogate(output)) throw new AssistantError("OUTPUT", "\u4F18\u5316\u7ED3\u679C\u5305\u542B\u4E0D\u5B8C\u6574\u5B57\u7B26\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
     if (charCount(output) > prepared.config.maxDraftChars * 2) throw new AssistantError("OUTPUT", "\u4F18\u5316\u7ED3\u679C\u8FC7\u957F\uFF0C\u5DF2\u4FDD\u7559\u539F\u7A3F");
     return output;
   }
   const cap = prepared.operation === "next" ? prepared.config.maxNextChars : prepared.config.maxCompletionChars;
-  if (charCount(raw) > cap || /[\r\n]/.test(trimmed) || /^(?:```|\{\s*"|<think>|(?:建议|预测|续写|Suggestion|Prediction)\s*[:：])/i.test(trimmed) || trimmed.includes(NO_SUGGESTION)) return null;
+  const allowNewlines = prepared.config.predictionDetail === "detailed";
+  if (charCount(raw) > cap || !allowNewlines && /[\r\n]/.test(raw) || /^(?:```|\{\s*"|<think>|(?:建议|预测|续写|Suggestion|Prediction)\s*[:：])/i.test(trimmed) || trimmed.includes(NO_SUGGESTION)) return null;
   if (prepared.operation === "next") return trimmed;
-  if (trimmed.startsWith(prepared.request.draft.trim()) || prepared.request.draft.endsWith(raw)) return null;
-  if (/[\uD800-\uDBFF]$/.test(raw) || /^[\uDC00-\uDFFF]/.test(raw)) return null;
-  return raw.replace(/[ \t]+$/, "");
+  const draft = prepared.request.draft.trim();
+  if (charCount(draft) >= 4 && trimmed.startsWith(draft) || prepared.request.draft.endsWith(raw)) return null;
+  return raw.replace(/\s+$/u, "");
 }
 
 // src/core/scheduler.ts