dsh-prompt-predict 0.1.0 → 0.2.0

package/lib/host-route.mjs

@@ -1,6 +1,7 @@
 // 同源 HTTP 接口：提示词预测 + 设置页（启用开关、模型选择、高级参数）。
-import { predictNextPrompt } from './predict.mjs';
+import { predictNextPrompt, resolveRoute } from './predict.mjs';
 import { readSettings, writeSettings, clearSettings } from './config.mjs';
+import { makeT, normalizeLang, listSeparator } from './messages.mjs';
 
 const MAX_BODY = 16 * 1024;
 
@@ -63,6 +64,16 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
   /** 有效设置 = 部署默认 + 用户保存的覆盖（每次请求时读取，改设置立即生效）。 */
   const effective = () => ({ ...deployDefaults, ...readSettings() });
 
+  // 每个会话上一条已展示的建议：用于「避免复读」——模型很容易连续两轮给出几乎相同的建议。
+  // 只存内存，进程重启即清空（不需要持久化，也不涉及隐私）。
+  const lastSuggestion = new Map();
+
+  /** 请求体里的路由（显式指定优先，其次读设置；都是 auto 时返回 undefined = 跟随会话）。 */
+  const routeFrom = (body, eff) =>
+    (typeof body?.provider === 'string' && typeof body?.model === 'string' && body.provider && body.model)
+      ? routeOf(body.provider, body.model)
+      : routeOf(eff.provider, eff.model);
+
 
   async function catalogGroups() {
     const providers = ctx.llm.listProviders();
@@ -76,33 +87,33 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
     }));
   }
 
-  async function validateRoute(provider, model) {
+  async function validateRoute(t, provider, model) {
     try {
       const models = await ctx.llm.listModels(provider);
-      if (!models.some((m) => m.id === model)) return `provider "${provider}" 没有模型 "${model}"`;
+      if (!models.some((m) => m.id === model)) return t('err.modelUnknown', { provider, model });
       return null;
     } catch (error) {
-      return `provider "${provider}" 不可用：${String(error?.message ?? error)}`;
+      return t('err.providerUnavailable', { provider, detail: String(error?.message ?? error) });
     }
   }
 
-  async function validateEffort(provider, model, effort) {
-    if (!['off', 'low', 'high', 'max'].includes(effort)) return '不支持的思考深度';
+  async function validateEffort(t, lang, provider, model, effort) {
+    if (!['off', 'low', 'high', 'max'].includes(effort)) return t('err.effortUnsupported');
     const controller = new AbortController();
     let timer;
     try {
       const info = await Promise.race([
         ctx.llm.resolveModelInfo(provider, model, controller.signal),
         new Promise((_, reject) => {
-          timer = setTimeout(() => { controller.abort(); reject(new Error('模型能力查询超时')); }, 3500);
+          timer = setTimeout(() => { controller.abort(); reject(new Error(t('err.effortQueryTimeout'))); }, 3500);
         }),
       ]);
       const efforts = info?.reasoning?.efforts?.map((e) => e.id) ?? [];
-      if (efforts.length === 0) return `模型 "${model}" 未公布可调思考深度，请选「跟随模型默认」`;
-      if (!efforts.includes(effort)) return `模型 "${model}" 不支持思考深度 "${effort}"（可选：${efforts.join('、')}）`;
+      if (efforts.length === 0) return t('err.effortNoLevels', { model });
+      if (!efforts.includes(effort)) return t('err.effortLevelUnsupported', { model, effort, options: efforts.join(listSeparator(lang)) });
       return null;
     } catch {
-      return '暂时无法确认模型支持的思考深度，请选「跟随模型默认」后保存';
+      return t('err.effortUnknown');
     } finally {
       clearTimeout(timer);
     }
@@ -124,12 +135,29 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
       }
 
       const path = new URL(req.url ?? '/', 'http://x').pathname;
+      // 语言由客户端在请求头带来（默认情况下 profile 的 cordis.patch.yml 里没有偏好，读不到）
+      const lang = normalizeLang(req.headers['x-dsh-locale']);
+      const t = makeT(lang);
 
       if (path === '/dsh-prompt-predict/status' && req.method === 'GET') {
         const current = currentSelection();
+        // 可选 sessionId：带上时回传「该会话实际使用的模型」，设置页据此生成思考档位。
+        // 不带 sessionId 时只能给全局默认——两者可能不同，混用会让档位选项对不上真实调用。
+        const sid = new URL(req.url ?? '/', 'http://x').searchParams.get('sessionId') ?? '';
+        let sessionModel = null;
+        if (sid) {
+          try {
+            const session = ctx.sessions?.get?.(sid);
+            if (session) {
+              const resolved = resolveRoute(ctx, session) ?? {};
+              sessionModel = { provider: resolved.provider ?? null, model: resolved.model ?? null };
+            }
+          } catch { /* 拿不到就算了，客户端回退到 current */ }
+        }
         sendJson(res, 200, {
           ok: true,
           current: { provider: current.provider ?? null, model: current.model ?? null },
+          sessionModel,
           effective: effective(),
           saved: readSettings(),
           defaults: deployDefaults,
@@ -147,7 +175,7 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
         const url = new URL(req.url ?? '/', 'http://x');
         const provider = url.searchParams.get('provider') ?? '';
         const model = url.searchParams.get('model') ?? '';
-        if (!provider || !model) { sendJson(res, 400, { ok: false, reason: '缺少 provider 或 model' }); return; }
+        if (!provider || !model) { sendJson(res, 400, { ok: false, reason: t('err.missingRoute') }); return; }
         const controller = new AbortController();
         let timer;
         try {
@@ -158,7 +186,7 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
           const efforts = info?.reasoning?.efforts?.map((e) => e.id) ?? [];
           sendJson(res, 200, { ok: true, efforts, default: info?.reasoning?.defaultEffort ?? null });
         } catch {
-          sendJson(res, 200, { ok: false, reason: '暂时无法获取该模型支持的思考深度' });
+          sendJson(res, 200, { ok: false, reason: t('err.effortCatalog') });
         } finally {
           clearTimeout(timer);
         }
@@ -167,7 +195,7 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
 
       if (path === '/dsh-prompt-predict/settings' && req.method === 'POST') {
         const body = await readJson(req);
-        if (!body) { sendJson(res, 400, { ok: false, reason: '请求体不是合法 JSON' }); return; }
+        if (!body) { sendJson(res, 400, { ok: false, reason: t('err.badJson') }); return; }
         if (body.reset === true) {
           clearSettings();
           sendJson(res, 200, { ok: true, effective: effective(), saved: {} });
@@ -180,7 +208,7 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
             patch.provider = AUTO;
             patch.model = AUTO;
           } else {
-            const problem = await validateRoute(body.provider, body.model);
+            const problem = await validateRoute(t, body.provider, body.model);
             if (problem) { sendJson(res, 200, { ok: false, reason: problem }); return; }
             patch.provider = body.provider;
             patch.model = body.model;
@@ -188,14 +216,24 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
         }
         if (body.timeoutMs !== undefined) {
           const v = Number(body.timeoutMs);
-          if (!Number.isSafeInteger(v) || v < 1000 || v > 60000) { sendJson(res, 200, { ok: false, reason: '超时需在 1–60 秒之间' }); return; }
+          if (!Number.isSafeInteger(v) || v < 1000 || v > 60000) { sendJson(res, 200, { ok: false, reason: t('err.timeoutRange') }); return; }
           patch.timeoutMs = v;
         }
         if (body.maxMessages !== undefined) {
           const v = Number(body.maxMessages);
-          if (!Number.isSafeInteger(v) || v < 2 || v > 20) { sendJson(res, 200, { ok: false, reason: '上下文条数需在 2–20 之间' }); return; }
+          if (!Number.isSafeInteger(v) || v < 2 || v > 20) { sendJson(res, 200, { ok: false, reason: t('err.messagesRange') }); return; }
           patch.maxMessages = v;
         }
+        if (body.maxChars !== undefined) {
+          const v = Number(body.maxChars);
+          if (!Number.isSafeInteger(v) || v < 1000 || v > 20000) { sendJson(res, 200, { ok: false, reason: t('err.charsRange') }); return; }
+          patch.maxChars = v;
+        }
+        if (body.maxTokens !== undefined) {
+          const v = Number(body.maxTokens);
+          if (!Number.isSafeInteger(v) || v < 16 || v > 512) { sendJson(res, 200, { ok: false, reason: t('err.tokensRange') }); return; }
+          patch.maxTokens = v;
+        }
         if (body.reasoningEffort !== undefined) {
           const v = String(body.reasoningEffort);
           if (v === 'auto') { patch.reasoningEffort = 'auto'; }
@@ -203,7 +241,7 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
             const next = { ...effective(), ...patch };
             // 跟随当前会话模型时模型不固定，无法按具体模型校验档位，直接按用户选择保存。
             const pinned = routeOf(next.provider, next.model);
-            const problem = pinned ? await validateEffort(pinned.provider, pinned.model, v) : null;
+            const problem = pinned ? await validateEffort(t, lang, pinned.provider, pinned.model, v) : null;
             if (problem) { sendJson(res, 200, { ok: false, reason: problem }); return; }
             patch.reasoningEffort = v;
           }
@@ -214,46 +252,88 @@ export function registerPredictRoute(ctx, cordisConfig = {}) {
       }
 
       if (path !== '/dsh-prompt-predict/suggest' || req.method !== 'POST') {
-        sendJson(res, 404, { ok: false, reason: 'not found' });
+        sendJson(res, 404, { ok: false, reason: t('err.notFound') });
         return;
       }
 
       const eff = effective();
       if (eff.enabled === false) {
-        sendJson(res, 200, { ok: false, disabled: true, reason: '提示词联想已关闭' });
+        sendJson(res, 200, { ok: false, disabled: true, reason: t('err.disabled') });
         return;
       }
 
       const body = await readJson(req);
       if (!body || typeof body.sessionId !== 'string' || body.sessionId.trim() === '') {
-        sendJson(res, 400, { ok: false, reason: '缺少 sessionId' });
+        sendJson(res, 400, { ok: false, reason: t('err.missingSessionId') });
         return;
       }
       const session = ctx.sessions.get(body.sessionId);
       if (!session) {
-        sendJson(res, 404, { ok: false, reason: 'Session 不存在' });
+        sendJson(res, 404, { ok: false, reason: t('err.sessionNotFound') });
         return;
       }
 
+      const startedAt = Date.now();
       const abort = new AbortController();
       const timeout = setTimeout(() => abort.abort('prediction timeout'), Number(eff.timeoutMs) || 12000);
       const onClose = () => { if (!res.writableEnded) abort.abort('client disconnected'); };
       res.on('close', onClose);
+      const base = {
+        signal: abort.signal,
+        maxTokens: Number(eff.maxTokens) || 64,
+        maxMessages: Number(eff.maxMessages) || 8,
+        maxChars: Number(eff.maxChars) || 6000,
+        route: routeFrom(body, eff),
+        t,
+      };
+      const effort = typeof body.reasoningEffort === 'string' ? body.reasoningEffort
+        : (eff.reasoningEffort && eff.reasoningEffort !== 'auto' ? eff.reasoningEffort : undefined);
+      // 上一条建议：客户端可以显式传 avoid（reroll 时带当前这条），否则用本会话记忆的那条。
+      const previous = (typeof body.avoid === 'string' && body.avoid.trim())
+        ? body.avoid.trim()
+        : lastSuggestion.get(session.id);
+      // reroll = 用户点了「换一条」：首轮就带 avoid，别白跑一次
+      const reroll = body.reroll === true && !!previous;
+      const firstExtra = reroll ? { avoid: previous, forceDifferent: true } : {};
+      let effortDropped = false;
+      let dedupRetry = false;
       try {
-        const result = await predictNextPrompt(ctx, session, {
-          signal: abort.signal,
-          maxTokens: Number(eff.maxTokens) || 64,
-          maxMessages: Number(eff.maxMessages) || 8,
-          maxChars: Number(eff.maxChars) || 6000,
-          route: (typeof body.provider === 'string' && typeof body.model === 'string' && body.provider && body.model)
-            ? routeOf(body.provider, body.model)
-            : routeOf(eff.provider, eff.model),
-          reasoningEffort: typeof body.reasoningEffort === 'string' ? body.reasoningEffort
-            : (eff.reasoningEffort && eff.reasoningEffort !== 'auto' ? eff.reasoningEffort : undefined),
+        let result;
+        try {
+          result = await predictNextPrompt(ctx, session, { ...base, reasoningEffort: effort, ...firstExtra });
+        } catch (error) {
+          // 降级：思考档位与真实模型不兼容（「跟随会话模型」时最常见）就丢掉档位再试一次。
+          // 不做这步的话，用户看到的是「设置都对、但永远没有建议」——而失败在客户端是静默的，最难排查。
+          if (!effort) throw error;
+          effortDropped = true;
+          result = await predictNextPrompt(ctx, session, { ...base, ...firstExtra });
+        }
+        // 去重：模型会「复读」，连续两轮给同一条时要求换一条（一次为限，失败就保留原建议）。
+        if (previous && result.suggestion === previous) {
+          try {
+            const retry = await predictNextPrompt(ctx, session, {
+              ...base,
+              reasoningEffort: effortDropped ? undefined : effort,
+              avoid: previous,
+              forceDifferent: true,
+            });
+            if (retry.suggestion && retry.suggestion !== previous) { result = retry; dedupRetry = true; }
+          } catch { /* 换一条失败就保留原建议，不打断用户 */ }
+        }
+        lastSuggestion.set(session.id, result.suggestion);
+        sendJson(res, 200, {
+          ok: true,
+          suggestion: result.suggestion,
+          provider: result.route.provider,
+          model: result.route.model,
+          ms: Date.now() - startedAt,
+          effortDropped,
+          dedupRetry,
         });
-        sendJson(res, 200, { ok: true, suggestion: result.suggestion, provider: result.route.provider, model: result.route.model });
       } catch (error) {
-        if (!res.writableEnded) sendJson(res, 200, { ok: false, reason: String(error?.message ?? error) });
+        if (!res.writableEnded) {
+          sendJson(res, 200, { ok: false, reason: String(error?.message ?? error), ms: Date.now() - startedAt });
+        }
       } finally {
         clearTimeout(timeout);
         res.off('close', onClose);

package/lib/messages.mjs

@@ -0,0 +1,96 @@
+/**
+ * Host 端面向用户的文案（中英双语）。
+ *
+ * 为什么 Host 也要有一份：设置页里显示的校验错误、预测失败原因都由 Host 生成，
+ * 客户端只是把 `reason` 原样显示出来。只做客户端 i18n 的话，切到英文后
+ * 「设置里的报错还是中文」——正是要修的那个不一致。
+ *
+ * 语言从哪来：由客户端在请求头 `x-dsh-locale` 里带上当前语言。
+ * 不读 profile 的 cordis.patch.yml，因为**默认情况下那里根本没有条目**
+ * （用户没手动切过语言时靠浏览器语言自动判定，不落盘）——按文件读只会在
+ * 最常见的情形下退回中文，等于没做。
+ *
+ * 这里只放 UI 文案；发给模型的提示词（predict.mjs 里的 framing / avoidHint）不在此列。
+ */
+
+export const MESSAGES = {
+  zh: {
+    'err.notFound': 'not found',
+    'err.unauthorized': 'unauthorized',
+    'err.badJson': '请求体不是合法 JSON',
+    'err.missingRoute': '缺少 provider 或 model',
+    'err.missingSessionId': '缺少 sessionId',
+    'err.sessionNotFound': 'Session 不存在',
+    'err.disabled': '提示词联想已关闭',
+    'err.timeoutRange': '超时需在 1–60 秒之间',
+    'err.messagesRange': '上下文条数需在 2–20 之间',
+    'err.charsRange': '上下文预算需在 1000–20000 字符之间',
+    'err.tokensRange': '输出上限需在 16–512 token 之间',
+    'err.effortUnsupported': '不支持的思考深度',
+    'err.modelUnknown': 'provider "{provider}" 没有模型 "{model}"',
+    'err.providerUnavailable': 'provider "{provider}" 不可用：{detail}',
+    'err.effortNoLevels': '模型 "{model}" 未公布可调思考深度，请选「跟随模型默认」',
+    'err.effortLevelUnsupported': '模型 "{model}" 不支持思考深度 "{effort}"（可选：{options}）',
+    'err.effortUnknown': '暂时无法确认模型支持的思考深度，请选「跟随模型默认」后保存',
+    'err.effortCatalog': '暂时无法获取该模型支持的思考深度',
+    'err.effortQueryTimeout': '模型能力查询超时',
+    'err.noHistory': '没有可用于预测的会话文本',
+    'err.noRoute': '无法确定联想所用模型，请在「设置 → 提示词联想」里显式选择提供商与模型',
+    'err.callFailed': '模型调用{kind}',
+    'err.noSuggestion': '模型未生成有效建议{detail}',
+    'err.reasoningOnly': '（模型只返回 reasoning：{text}）',
+  },
+  en: {
+    'err.notFound': 'not found',
+    'err.unauthorized': 'unauthorized',
+    'err.badJson': 'Request body is not valid JSON',
+    'err.missingRoute': 'Missing provider or model',
+    'err.missingSessionId': 'Missing sessionId',
+    'err.sessionNotFound': 'Session not found',
+    'err.disabled': 'Prompt prediction is turned off',
+    'err.timeoutRange': 'Timeout must be between 1 and 60 seconds',
+    'err.messagesRange': 'Context size must be between 2 and 20 messages',
+    'err.charsRange': 'Context budget must be between 1000 and 20000 characters',
+    'err.tokensRange': 'Output cap must be between 16 and 512 tokens',
+    'err.effortUnsupported': 'Unsupported reasoning effort',
+    'err.modelUnknown': 'Provider "{provider}" has no model "{model}"',
+    'err.providerUnavailable': 'Provider "{provider}" is unavailable: {detail}',
+    'err.effortNoLevels': 'Model "{model}" publishes no adjustable reasoning levels; choose "Follow the model default"',
+    'err.effortLevelUnsupported': 'Model "{model}" does not support reasoning level "{effort}" (available: {options})',
+    'err.effortUnknown': 'Cannot confirm the supported reasoning levels right now; choose "Follow the model default" and save',
+    'err.effortCatalog': 'Cannot fetch the supported reasoning levels for this model right now',
+    'err.effortQueryTimeout': 'Model capability query timed out',
+    'err.noHistory': 'No conversation text available for prediction',
+    'err.noRoute': 'Cannot determine which model to use; pick a provider and model under Settings → Prompt suggestions',
+    'err.callFailed': 'Model call {kind}',
+    'err.noSuggestion': 'Model produced no usable suggestion{detail}',
+    'err.reasoningOnly': ' (model returned only reasoning: {text})',
+  },
+};
+
+/** 任意输入 → 'zh' | 'en'；认不出来一律按中文（插件的原始语言）。 */
+export function normalizeLang(value) {
+  const raw = Array.isArray(value) ? value[0] : value;
+  const text = String(raw ?? '').trim().toLowerCase();
+  if (!text) return 'zh';
+  if (text.startsWith('zh')) return 'zh';
+  if (text.startsWith('en')) return 'en';
+  return 'zh';
+}
+
+/** 列表分隔符也要跟着语言走：中文用顿号，英文用逗号。 */
+export function listSeparator(lang) {
+  return lang === 'zh' ? '、' : ', ';
+}
+
+/** 生成翻译函数：{name} 占位符由自己做，词序交给各语言的模板。 */
+export function makeT(lang) {
+  const dict = MESSAGES[lang] ?? MESSAGES.zh;
+  return function t(key, vars) {
+    let text = dict[key] ?? MESSAGES.zh[key] ?? key;
+    if (vars) {
+      text = text.replace(/\{(\w+)\}/g, (m, k) => (vars[k] === undefined || vars[k] === null ? m : String(vars[k])));
+    }
+    return text;
+  };
+}

package/lib/predict.mjs

@@ -1,5 +1,9 @@
 // 提示词预测核心：会话裁剪 → 调当前会话模型 → 归一化为一条可直接发送的建议。
 import { randomUUID } from 'node:crypto';
+import { makeT } from './messages.mjs';
+
+// 默认按中文；Host 路由会按请求带来的语言换一个 t 进来。
+const defaultT = makeT('zh');
 
 const DEFAULT_SYSTEM = `你是输入框预测器。根据当前对话，预测用户下一条最可能发给助手的消息。
 规则：
@@ -55,7 +59,11 @@ export function normalizeSuggestion(input, maxChars = 180) {
   return text;
 }
 
-function selectionFor(ctx, session) {
+/**
+ * 解析某次预测实际使用的路由：优先会话自身选用的模型，其次全局默认。
+ * 导出给 host 端复用——设置页展示「会话实际模型」时要用同一套解析，避免两处口径不一致。
+ */
+export function resolveRoute(ctx, session) {
   try {
     const header = session?.requestHeader?.();
     const config = header?.config;
@@ -66,6 +74,15 @@ function selectionFor(ctx, session) {
   return ctx.agentDefaultModel.currentSelection();
 }
 
+/** 拼「避免重复」提示：prefer 只作偏好，force 要求必须换一条。 */
+function avoidHint(avoid, forceDifferent) {
+  if (typeof avoid !== 'string' || !avoid.trim()) return '';
+  const text = avoid.trim().slice(0, 200);
+  return forceDifferent
+    ? `\n\n必须给出与下面这条**不同**的建议（用户已经看过它了，不要原样重复、也不要只改标点）：\n${text}`
+    : `\n\n上一轮已经给过这条建议；如果它仍是当前最合适的可以再次给出，否则请换一条更贴合当前进展的：\n${text}`;
+}
+
 /** 生成一条建议。 */
 export async function predictNextPrompt(ctx, session, {
   signal,
@@ -75,12 +92,15 @@ export async function predictNextPrompt(ctx, session, {
   system = DEFAULT_SYSTEM,
   route: routeOverride,
   reasoningEffort,
+  avoid,
+  forceDifferent = false,
+  t = defaultT,
 } = {}) {
   const history = recentMessages(session?.deriveMessages?.() ?? [], { maxMessages, maxChars });
-  if (history.length === 0) throw new Error('没有可用于预测的会话文本');
-  const route = routeOverride ?? selectionFor(ctx, session);
+  if (history.length === 0) throw new Error(t('err.noHistory'));
+  const route = routeOverride ?? resolveRoute(ctx, session);
   if (typeof route?.provider !== 'string' || typeof route?.model !== 'string') {
-    throw new Error('无法确定联想所用模型，请在「设置 → 提示词联想」里显式选择提供商与模型');
+    throw new Error(t('err.noRoute'));
   }
   const framedHistory = history.map((item) => {
     const label = item.role === 'user' ? '用户' : '助手';
@@ -94,7 +114,7 @@ export async function predictNextPrompt(ctx, session, {
     source: { kind: 'dsh-prompt-predict' },
     content: [{
       type: 'text',
-      text: `以下是当前会话最近内容：\n\n${framedHistory}\n\n请预测我下一条最可能输入的消息。只输出预测内容。`,
+      text: `以下是当前会话最近内容：\n\n${framedHistory}\n\n请预测我下一条最可能输入的消息。只输出预测内容。${avoidHint(avoid, forceDifferent)}`,
     }],
   }];
   let output = '';
@@ -119,12 +139,12 @@ export async function predictNextPrompt(ctx, session, {
   }
   if (finish?.kind === 'error' || finish?.kind === 'aborted') {
     const failure = finish.failure;
-    throw new Error(failure?.message ?? failure?.code ?? `模型调用${finish.kind}`);
+    throw new Error(failure?.message ?? failure?.code ?? t('err.callFailed', { kind: finish.kind }));
   }
   const suggestion = normalizeSuggestion(output);
   if (!suggestion) {
-    const detail = reasoning.trim() ? `（模型只返回 reasoning：${normalizeSuggestion(reasoning, 80)}）` : '';
-    throw new Error(`模型未生成有效建议${detail}`);
+    const detail = reasoning.trim() ? t('err.reasoningOnly', { text: normalizeSuggestion(reasoning, 80) }) : '';
+    throw new Error(t('err.noSuggestion', { detail }));
   }
   return { suggestion, route, historySize: history.length };
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-prompt-predict",
-  "version": "0.1.0",
-  "description": "Codex-style composer predictions for DeepSeek Harness: suggest the user's next prompt after each reply and accept it with Tab.",
+  "version": "0.2.0",
+  "description": "输入框提示词联想插件：助手回复结束后预测你的下一句话，以灰色 ghost text 浮在输入框里，Tab 采纳、Esc 忽略 ｜ Codex-style composer prompt predictions for DeepSeek Harness: your next message ghosted into the composer, accepted with Tab.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
@@ -15,10 +15,13 @@
     "lib",
     "client",
     "cordis.patch.yml",
-    "README.md"
+    "README.md",
+    "README.zh.md",
+    "CHANGELOG.md",
+    "CHANGELOG.zh.md"
   ],
   "scripts": {
-    "test": "node test/predict.mjs",
+    "test": "node test/predict.mjs && node test/client-render.mjs",
     "pack": "pnpm pack"
   },
   "repository": {