dsh-input-assistant 0.1.3 → 0.1.4

package/lib/index.js

@@ -9,6 +9,7 @@ var DEFAULT_CONFIG = Object.freeze({
   optimizationStrength: "standard",
   nextEnabled: true,
   completionEnabled: true,
+  predictionDetail: "standard",
   displayMode: "ghost",
   debounceMs: 600,
   minIntervalMs: 2e3,
@@ -35,8 +36,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]
 };
@@ -48,6 +49,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) {
@@ -69,6 +71,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 };
@@ -79,9 +82,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;
 }
@@ -119,7 +124,7 @@ function buildContext(history, budget = 16e3) {
 }
 
 // src/core/protection.ts
-var FILE_EXTENSIONS = [
+var FILE_EXTENSIONS = /* @__PURE__ */ new Set([
   "json",
   "jsonc",
   "json5",
@@ -209,8 +214,8 @@ var FILE_EXTENSIONS = [
   "stylelintrc",
   "babelrc",
   "browserslistrc"
-].join("|");
-var NAMED_FILES = [
+]);
+var NAMED_FILES = /* @__PURE__ */ new Set([
   "LICENSE",
   "LICENCE",
   "README",
@@ -227,28 +232,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((name2) => value === name2 || value.startsWith(name2 + ".")) || 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((name2) => first.slice(dot) === name2 || first.slice(dot).startsWith(name2 + ".")) && Array.from(stem).every((char) => cjkCharacter.test(char))) return dot;
+  return start;
+}
+function candidateRanges(value, base) {
   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;
+  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((name2) => tail.startsWith(name2) && /[. \t]/.test(tail[name2.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 = [];
+  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);
@@ -264,8 +434,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) {
@@ -278,19 +454,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;
 }
 
@@ -311,6 +488,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);
@@ -335,18 +519,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");
@@ -365,11 +553,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");
@@ -377,16 +600,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
@@ -441,19 +668,101 @@ var SessionScheduler = class {
 };
 
 // src/host/runtime.ts
-import { randomUUID } from "node:crypto";
-import { z as z2 } from "zod";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { z as z3 } from "zod";
 import { Session } from "@deepseek-ai/dsh-session";
 import { BlockAssembler } from "@deepseek-ai/dsh-llm";
 
-// src/host/transcript.ts
+// src/host/storage.ts
 import { z } from "zod";
-var transcriptSchema = z.object({
-  entries: z.array(z.object({ role: z.enum(["user", "assistant"]), text: z.string(), turnId: z.string().optional() })),
-  currentTurn: z.number().int().nonnegative(),
-  sourceTurnId: z.string().nullable(),
-  running: z.boolean(),
-  pendingAssistant: z.string().nullable()
+import { randomUUID } from "node:crypto";
+import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
+var draftSchema = z.object({ id: z.string().min(1).max(300), text: z.string().min(1).max(64e3).refine((text) => charCount(text) <= 32e3), createdAt: z.number().int().nonnegative() });
+var sessionDraftsSchema = z.object({ version: z.literal(1), drafts: z.array(draftSchema).max(3) });
+function createDomainSpec(initial) {
+  return defineDomain({
+    name: "input_assistant",
+    version: 1,
+    layout: "per-record",
+    global: { schema: z.object({ version: z.literal(1), settings: z.record(z.string(), z.unknown()) }), initial: { version: 1, settings: { ...initial } } },
+    tables: { drafts: domainTable(sessionDraftsSchema) }
+  });
+}
+var AssistantStorage = class {
+  constructor(domain) {
+    this.domain = domain;
+  }
+  chain = Promise.resolve();
+  transaction(work) {
+    const task = this.chain.then(async () => work(await this.domain()));
+    this.chain = task.then(() => void 0, () => void 0);
+    return task;
+  }
+  async settings() {
+    const domain = await this.domain();
+    return resolveStoredConfig(domain.global.get().settings);
+  }
+  updateSettings(patch) {
+    return this.transaction(async (domain) => {
+      const settings = resolveConfig({ ...resolveStoredConfig(domain.global.get().settings), ...patch });
+      await domain.global.set({ version: 1, settings });
+      return settings;
+    });
+  }
+  async list(sessionId) {
+    return (await this.domain()).table("drafts").get(sessionId)?.drafts.map((draft) => ({ ...draft })) ?? [];
+  }
+  save(sessionId, text, replaceId) {
+    if (text.trim().length === 0 || text.length > 64e3 || charCount(text) > 32e3) throw new AssistantError("DRAFT", "\u6682\u5B58\u5185\u5BB9\u4E3A\u7A7A\u6216\u8D85\u8FC7 32,000 \u5B57\u7B26");
+    return this.transaction(async (domain) => {
+      const drafts = [...domain.table("drafts").get(sessionId)?.drafts ?? []];
+      const index = replaceId === void 0 ? -1 : drafts.findIndex((draft) => draft.id === replaceId);
+      if (replaceId !== void 0 && index < 0) throw new AssistantError("DRAFT_NOT_FOUND", "\u8981\u66FF\u6362\u7684\u6682\u5B58\u8349\u7A3F\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5237\u65B0\u5217\u8868");
+      if (drafts.length >= 3 && index < 0) throw new AssistantError("DRAFT_LIMIT", "\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6682\u5B58\u4E09\u6761\uFF0C\u8BF7\u9009\u62E9\u66FF\u6362\u6216\u5220\u9664\u4E00\u6761");
+      const next = { id: replaceId ?? randomUUID(), text, createdAt: Date.now() };
+      if (index < 0) drafts.push(next);
+      else drafts[index] = next;
+      await domain.table("drafts").put(sessionId, { version: 1, drafts });
+      return drafts.map((draft) => ({ ...draft }));
+    });
+  }
+  delete(sessionId, id) {
+    return this.transaction(async (domain) => {
+      const current = domain.table("drafts").get(sessionId)?.drafts ?? [];
+      const drafts = id === void 0 ? [] : current.filter((draft) => draft.id !== id);
+      const removed = id === void 0 ? current : current.filter((draft) => draft.id === id);
+      if (drafts.length === 0) await domain.table("drafts").delete(sessionId);
+      else await domain.table("drafts").put(sessionId, { version: 1, drafts });
+      return { drafts: drafts.map((draft) => ({ ...draft })), removed: removed.map((draft) => ({ ...draft })) };
+    });
+  }
+  /** Undo deletion without overwriting drafts created or changed elsewhere. */
+  restore(sessionId, deleted) {
+    const snapshots = z.array(draftSchema).max(3).parse(deleted);
+    return this.transaction(async (domain) => {
+      const drafts = [...domain.table("drafts").get(sessionId)?.drafts ?? []];
+      const ids = new Set(drafts.map((draft) => draft.id));
+      for (const snapshot of snapshots) {
+        if (!ids.has(snapshot.id)) {
+          drafts.push(snapshot);
+          ids.add(snapshot.id);
+        }
+      }
+      if (drafts.length > 3) throw new AssistantError("DRAFT_LIMIT", "\u5F53\u524D\u4F1A\u8BDD\u6682\u5B58\u7A7A\u95F4\u4E0D\u8DB3\uFF0C\u8BF7\u5220\u9664\u4E00\u6761\u540E\u518D\u64A4\u9500");
+      if (drafts.length) await domain.table("drafts").put(sessionId, { version: 1, drafts });
+      return drafts.map((draft) => ({ ...draft }));
+    });
+  }
+};
+
+// src/host/transcript.ts
+import { z as z2 } from "zod";
+var transcriptSchema = z2.object({
+  entries: z2.array(z2.object({ role: z2.enum(["user", "assistant"]), text: z2.string(), turnId: z2.string().optional() })),
+  currentTurn: z2.number().int().nonnegative(),
+  sourceTurnId: z2.string().nullable(),
+  running: z2.boolean(),
+  pendingAssistant: z2.string().nullable()
 });
 function emptyTranscript() {
   return { entries: [], currentTurn: 0, sourceTurnId: null, running: false, pendingAssistant: null };
@@ -492,36 +801,38 @@ function foldTranscript(state, event) {
 }
 
 // src/host/runtime.ts
-var stringId = z2.string().min(1).max(300);
-var sessionRequest = z2.object({ sessionId: stringId });
-var generationRequest = z2.object({
+var stringId = z3.string().min(1).max(300);
+var sessionRequest = z3.object({ sessionId: stringId });
+var inputText = z3.string().max(64e3).refine((value) => charCount(value) <= 32e3);
+var generationRequest = z3.object({
   requestId: stringId,
   sessionId: stringId,
-  operation: z2.enum(["optimize", "next", "complete"]),
-  sourceTurnId: z2.string().nullable(),
-  draft: z2.string().max(128e3),
-  draftRev: z2.number().int().nonnegative(),
-  span: z2.object({ start: z2.number().int().nonnegative(), end: z2.number().int().nonnegative(), draftRev: z2.number().int().nonnegative() }),
+  operation: z3.enum(["optimize", "next", "complete"]),
+  sourceTurnId: z3.string().nullable(),
+  draft: z3.string().max(128e3),
+  draftRev: z3.number().int().nonnegative(),
+  span: z3.object({ start: z3.number().int().nonnegative(), end: z3.number().int().nonnegative(), draftRev: z3.number().int().nonnegative() }),
   connectionGeneration: stringId,
-  routeKey: z2.string().max(1e3),
-  targetText: z2.string().max(32e3).optional(),
-  lockedFragments: z2.array(z2.string().min(1).max(32e3)).max(100).optional(),
-  provider: z2.string().max(200).optional(),
-  model: z2.string().max(200).optional()
+  routeKey: z3.string().max(1e3),
+  targetText: inputText.optional(),
+  lockedFragments: z3.array(inputText.refine((value) => value.length > 0)).max(100).optional(),
+  provider: z3.string().max(200).optional(),
+  model: z3.string().max(200).optional(),
+  manual: z3.boolean().optional()
 });
 var AssistantHostRuntime = class {
   constructor(ctx, storage) {
     this.ctx = ctx;
     this.storage = storage;
   }
-  mount = randomUUID();
+  mount = randomUUID2();
   instances = /* @__PURE__ */ new WeakMap();
   scheduler = new SessionScheduler();
   disposed = false;
   state(session) {
     let state = this.instances.get(session);
     if (!state) {
-      state = { generation: `${this.mount}:${randomUUID()}`, lastNextTurn: null, lastCompletionAt: 0 };
+      state = { generation: `${this.mount}:${randomUUID2()}`, nextTurn: null, nextRoutes: /* @__PURE__ */ new Set(), lastCompletionAt: -Infinity };
       this.instances.set(session, state);
     }
     return state;
@@ -558,9 +869,29 @@ var AssistantHostRuntime = class {
       ...route ? { route } : {}
     };
   }
-  result(request, text) {
+  async models(signal) {
+    signal.throwIfAborted();
+    if (this.disposed) throw new AssistantError("DISPOSED", "\u8F93\u5165\u52A9\u624B\u5DF2\u505C\u7528");
+    const directory = this.ctx.get("sessionController");
+    if (!directory) throw new AssistantError("MODEL_CATALOG", "\u5F53\u524D\u5BBF\u4E3B\u672A\u63D0\u4F9B\u6A21\u578B\u76EE\u5F55\uFF0C\u8BF7\u4F7F\u7528\u624B\u52A8\u586B\u5199");
+    const catalog = await directory.modelCatalog();
+    signal.throwIfAborted();
+    if (this.disposed) throw new AssistantError("DISPOSED", "\u8F93\u5165\u52A9\u624B\u5DF2\u505C\u7528");
+    return {
+      groups: catalog.groups.map((group) => ({
+        provider: group.id,
+        name: group.name,
+        models: group.models.filter((model) => model.id.length > 0 && model.id.length <= 200).map((model) => ({ id: model.id, name: model.name }))
+      })).filter((group) => group.provider.length > 0 && group.provider.length <= 200 && group.models.length > 0),
+      // Provider diagnostics can include private details; advertise only the failed provider identity.
+      failures: catalog.failures.map((failure) => ({ provider: failure.id, name: failure.name }))
+    };
+  }
+  result(request, text, retryAfterMs) {
     return {
       text,
+      outcome: retryAfterMs === void 0 ? text === null ? "abstained" : "suggestion" : "throttled",
+      ...retryAfterMs === void 0 ? {} : { retryAfterMs },
       requestId: request.requestId,
       sessionId: request.sessionId,
       sourceTurnId: request.sourceTurnId,
@@ -594,20 +925,28 @@ var AssistantHostRuntime = class {
     const state = this.state(session);
     const transcript = this.transcript(session);
     if (request.operation === "next") {
-      if (!settings.nextEnabled || transcript.running || request.sourceTurnId === null || request.draft.length > 0 || state.lastNextTurn === request.sourceTurnId) return this.result(request, null);
-      state.lastNextTurn = request.sourceTurnId;
+      if (!request.manual && !settings.nextEnabled || transcript.running || request.sourceTurnId === null || request.draft.length > 0) return this.result(request, null);
     } else if (request.operation === "complete") {
-      if (!settings.completionEnabled || transcript.running) return this.result(request, null);
-      const now = Date.now();
-      if (now - state.lastCompletionAt < settings.minIntervalMs) return this.result(request, null);
-      state.lastCompletionAt = now;
+      if (!request.manual && !settings.completionEnabled || transcript.running) return this.result(request, null);
     }
     const fallback = this.sessionRoute(session);
     const provider = settings.provider || request.provider || fallback?.provider;
     const model = settings.model || request.model || fallback?.model;
     if (!provider || !model) throw new AssistantError("MODEL", "\u8BF7\u5148\u5728 DSH \u8F93\u5165\u6846\u9009\u62E9\u53EF\u7528\u6A21\u578B\uFF0C\u6216\u5728\u8F93\u5165\u52A9\u624B\u8BBE\u7F6E\u8F85\u52A9\u6A21\u578B");
+    const actualRoute = JSON.stringify([provider, model]);
+    if (request.operation === "next") {
+      if (state.nextTurn !== request.sourceTurnId) {
+        state.nextTurn = request.sourceTurnId;
+        state.nextRoutes.clear();
+      }
+      if (!request.manual && state.nextRoutes.has(actualRoute)) return this.result(request, null);
+    } else if (request.operation === "complete") {
+      const retryAfterMs = settings.minIntervalMs - (Date.now() - state.lastCompletionAt);
+      if (retryAfterMs > 0) return this.result(request, null, retryAfterMs);
+    }
     const prepared = prepareGeneration(request, transcript.entries, settings);
     const text = await this.scheduler.run(request.sessionId, request.requestId, request.operation, prepared.timeoutMs, async (active) => {
+      if (request.operation === "complete") state.lastCompletionAt = Date.now();
       const call = await this.ctx.llm.prepareCall({ provider, model, maxTokens: prepared.maxOutputTokens }, active, (controls, info) => {
         const effort = info.reasoning?.efforts[0]?.id;
         return effort === void 0 ? { ...controls } : { ...controls, reasoningEffort: effort };
@@ -636,6 +975,10 @@ var AssistantHostRuntime = class {
       return finishGeneration(raw, prepared);
     }, signal);
     this.current(request, session);
+    if (request.operation === "next") {
+      if (state.nextRoutes.size >= 512) state.nextRoutes.clear();
+      state.nextRoutes.add(actualRoute);
+    }
     return this.result(request, text);
   }
   cancel(id, requestId) {
@@ -653,10 +996,12 @@ var AssistantHostRuntime = class {
     switch (payload.method) {
       case "generate":
         return this.generate(payload.data, signal);
+      case "models/list":
+        return this.models(signal);
       case "settings/get":
         return this.storage.settings();
       case "settings/set": {
-        const patch = z2.record(z2.string(), z2.unknown()).parse(payload.data);
+        const patch = z3.record(z3.string(), z3.unknown()).parse(payload.data);
         const result = await this.storage.updateSettings(patch);
         this.scheduler.cancelAll();
         return result;
@@ -664,7 +1009,7 @@ var AssistantHostRuntime = class {
       case "status":
         return this.status(sessionRequest.parse(payload.data).sessionId, signal);
       case "cancel": {
-        const request = z2.object({ sessionId: stringId, requestId: stringId.optional() }).parse(payload.data);
+        const request = z3.object({ sessionId: stringId, requestId: stringId.optional() }).parse(payload.data);
         await this.session(request.sessionId, signal);
         return { cancelled: this.cancel(request.sessionId, request.requestId) };
       }
@@ -674,7 +1019,7 @@ var AssistantHostRuntime = class {
         return this.storage.list(request.sessionId);
       }
       case "drafts/save": {
-        const request = z2.object({ sessionId: stringId, text: z2.string().max(32e3), replaceId: stringId.optional() }).parse(payload.data);
+        const request = z3.object({ sessionId: stringId, text: inputText, replaceId: stringId.optional() }).parse(payload.data);
         await this.session(request.sessionId, signal);
         if (!(await this.storage.settings()).stashEnabled) {
           throw new AssistantError("DISABLED", "\u8349\u7A3F\u6682\u5B58\u5DF2\u5173\u95ED\uFF0C\u8BF7\u5728\u8F93\u5165\u52A9\u624B\u8BBE\u7F6E\u4E2D\u542F\u7528\uFF1B\u5DF2\u6709\u8349\u7A3F\u4ECD\u53EF\u67E5\u770B\u6216\u5220\u9664");
@@ -682,7 +1027,7 @@ var AssistantHostRuntime = class {
         return this.storage.save(request.sessionId, request.text, request.replaceId);
       }
       case "drafts/delete": {
-        const request = z2.object({ sessionId: stringId, id: stringId }).parse(payload.data);
+        const request = z3.object({ sessionId: stringId, id: stringId }).parse(payload.data);
         await this.session(request.sessionId, signal);
         return this.storage.delete(request.sessionId, request.id);
       }
@@ -691,79 +1036,20 @@ var AssistantHostRuntime = class {
         await this.session(request.sessionId, signal);
         return this.storage.delete(request.sessionId);
       }
+      case "drafts/restore": {
+        const request = z3.object({ sessionId: stringId, drafts: z3.array(draftSchema).max(3) }).parse(payload.data);
+        await this.session(request.sessionId, signal);
+        return this.storage.restore(request.sessionId, request.drafts);
+      }
     }
   }
 };
 
-// src/host/storage.ts
-import { z as z3 } from "zod";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
-var draftSchema = z3.object({ id: z3.string().min(1), text: z3.string().min(1).max(32e3), createdAt: z3.number().int().nonnegative() });
-var sessionDraftsSchema = z3.object({ version: z3.literal(1), drafts: z3.array(draftSchema).max(3) });
-function createDomainSpec(initial) {
-  return defineDomain({
-    name: "input_assistant",
-    version: 1,
-    layout: "per-record",
-    global: { schema: z3.object({ version: z3.literal(1), settings: z3.record(z3.string(), z3.unknown()) }), initial: { version: 1, settings: { ...initial } } },
-    tables: { drafts: domainTable(sessionDraftsSchema) }
-  });
-}
-var AssistantStorage = class {
-  constructor(domain) {
-    this.domain = domain;
-  }
-  chain = Promise.resolve();
-  transaction(work) {
-    const task = this.chain.then(async () => work(await this.domain()));
-    this.chain = task.then(() => void 0, () => void 0);
-    return task;
-  }
-  async settings() {
-    const domain = await this.domain();
-    return resolveStoredConfig(domain.global.get().settings);
-  }
-  updateSettings(patch) {
-    return this.transaction(async (domain) => {
-      const settings = resolveConfig({ ...resolveStoredConfig(domain.global.get().settings), ...patch });
-      await domain.global.set({ version: 1, settings });
-      return settings;
-    });
-  }
-  async list(sessionId) {
-    return (await this.domain()).table("drafts").get(sessionId)?.drafts.map((draft) => ({ ...draft })) ?? [];
-  }
-  save(sessionId, text, replaceId) {
-    if (text.trim().length === 0 || text.length > 32e3) throw new AssistantError("DRAFT", "\u6682\u5B58\u5185\u5BB9\u4E3A\u7A7A\u6216\u8D85\u8FC7 32,000 \u5B57\u7B26");
-    return this.transaction(async (domain) => {
-      const drafts = [...domain.table("drafts").get(sessionId)?.drafts ?? []];
-      const index = replaceId === void 0 ? -1 : drafts.findIndex((draft) => draft.id === replaceId);
-      if (replaceId !== void 0 && index < 0) throw new AssistantError("DRAFT_NOT_FOUND", "\u8981\u66FF\u6362\u7684\u6682\u5B58\u8349\u7A3F\u4E0D\u5B58\u5728\uFF0C\u8BF7\u5237\u65B0\u5217\u8868");
-      if (drafts.length >= 3 && index < 0) throw new AssistantError("DRAFT_LIMIT", "\u5F53\u524D\u4F1A\u8BDD\u5DF2\u6682\u5B58\u4E09\u6761\uFF0C\u8BF7\u9009\u62E9\u66FF\u6362\u6216\u5220\u9664\u4E00\u6761");
-      const next = { id: replaceId ?? randomUUID2(), text, createdAt: Date.now() };
-      if (index < 0) drafts.push(next);
-      else drafts[index] = next;
-      await domain.table("drafts").put(sessionId, { version: 1, drafts });
-      return drafts.map((draft) => ({ ...draft }));
-    });
-  }
-  delete(sessionId, id) {
-    return this.transaction(async (domain) => {
-      const current = domain.table("drafts").get(sessionId)?.drafts ?? [];
-      const drafts = id === void 0 ? [] : current.filter((draft) => draft.id !== id);
-      if (drafts.length === 0) await domain.table("drafts").delete(sessionId);
-      else await domain.table("drafts").put(sessionId, { version: 1, drafts });
-      return drafts.map((draft) => ({ ...draft }));
-    });
-  }
-};
-
 // src/host/rpc.ts
 import { z as z4 } from "zod";
 import { createTypertRemoteInfo } from "@deepseek-ai/dsh-typert-protocol/remote-info";
 var rpcPayloadSchema = z4.strictObject({
-  method: z4.enum(["status", "generate", "cancel", "drafts/list", "drafts/save", "drafts/delete", "drafts/clear", "settings/get", "settings/set"]),
+  method: z4.enum(["status", "generate", "cancel", "models/list", "drafts/list", "drafts/save", "drafts/delete", "drafts/clear", "drafts/restore", "settings/get", "settings/set"]),
   data: z4.json()
 });
 var inputCodec = {
@@ -802,13 +1088,14 @@ var Config = schema.object({
   optimizationStrength: schema.union(["light", "standard", "deep"]).default("standard"),
   nextEnabled: schema.boolean().default(true),
   completionEnabled: schema.boolean().default(true),
+  predictionDetail: schema.union(["concise", "standard", "detailed"]).default("standard"),
   displayMode: schema.union(["ghost", "panel"]).default("ghost"),
   debounceMs: schema.natural().min(200).max(5e3).default(600),
   minIntervalMs: schema.natural().min(500).max(3e4).default(2e3),
   maxHistoryChars: schema.natural().min(1e3).max(64e3).default(16e3),
   maxDraftChars: schema.natural().min(100).max(32e3).default(8e3),
-  maxNextChars: schema.natural().min(20).max(300).default(120),
-  maxCompletionChars: schema.natural().min(10).max(200).default(80),
+  maxNextChars: schema.natural().min(20).max(1e3).default(120),
+  maxCompletionChars: schema.natural().min(10).max(500).default(80),
   optimizeTimeoutMs: schema.natural().min(1e3).max(12e4).default(6e4),
   suggestionTimeoutMs: schema.natural().min(1e3).max(6e4).default(15e3),
   provider: schema.string().default(""),
@@ -834,7 +1121,15 @@ var InputAssistantService = class extends TypertRemoteService {
 function apply(ctx, config = {}) {
   const initial = resolveConfig({ ...DEFAULT_CONFIG, ...config });
   let opened;
-  const domain = () => opened ??= ctx.storageDomain.open(createDomainSpec(initial));
+  const domain = () => {
+    if (opened) return opened;
+    const attempt = Promise.resolve().then(() => ctx.storageDomain.open(createDomainSpec(initial)));
+    opened = attempt;
+    void attempt.catch(() => {
+      if (opened === attempt) opened = void 0;
+    });
+    return attempt;
+  };
   const runtime = new AssistantHostRuntime(ctx, new AssistantStorage(domain));
   ctx.sessionProjections.register({
     key: "inputAssistantTranscript",