mslxdff 0.1.57 → 0.1.62

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.57",
+  "version": "0.1.62",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {
@@ -8,7 +8,7 @@
   },
   "scripts": {
     "start": "node bin/mslxdff.js",
-    "test": "node --test test/*.test.js",
+    "test": "node --test --test-concurrency=1 test/*.test.js",
     "docs:check": "node scripts/docs-check.js"
   },
   "engines": {

package/src/auto.js

@@ -27,8 +27,8 @@ export function getPreferredModel({ file = defaultStateFile() } = {}) {
 
 export const DEFAULT_AUTO_MODELS = [
   PREFERRED_MODEL,
-  "deepseek-v4-flash-free",
   "mimo-v2.5-free",
+  "deepseek-v4-flash-free",
   "ling-3.0-flash-free",
   "nemotron-3-ultra-free",
   "north-mini-code-free",

package/src/chat/prompt.js

@@ -52,7 +52,9 @@ ${mini}
 - 永远输出精确的命令与模型 id，大小写敏感。
 - 需要执行命令时调用 run_command，需要看文件时调用 read_file，需要检查网络/服务可用性时调用 curl。
 - curl 简写：upstream(=上游 https://opencode.ai/zen/v1/models)、local/health(=本机 /health)、local/models(=本机 /v1/models)，也支持完整 http(s) URL；会自动补上游头、本机 token 与已配置供应商 key（直连 https://api.b.ai/v1/models 会自动带 bai 的 key，无需手动加头）。
-- 查“某供应商有哪些模型”：优先直接用上方“可用模型”按前缀过滤回答（如 bai/ 开头的即 bai 供应商），无需调工具；如需实时刷新，调 curl local/models（GET，自动带本机 token）看网关聚合列表，或 curl https://api.b.ai/v1/models（自动带 key）看上游全量。禁止为此调用 -showtoken（本机 token 已自动注入）。
+- 查“某供应商有哪些模型”**禁止调用 run_command**：**直接用上方“可用模型”按前缀过滤回答**（如 workbuddy/ 开头的即 workbuddy 供应商，clinebot/ 开头即 clinebot），无需调工具；如需实时刷新，调 curl local/models（GET，自动带本机 token）看网关聚合列表。**错误示例**：用户问 workbuddy有哪些模型 → 调用 -provider workbuddy list（这是查配置，不是查模型！）→ 错。**正确**：直接列 workbuddy/ 前缀的可用模型。禁止为此调用 -showtoken（本机 token 已自动注入）。
+- 严禁幻觉命令：mslxdff "hi" --model X / mslxdff --model X "hi" / mslxdff -chat --model X 都不存在，输出只会是 status 页。探活任意模型（含 clinebot/*、workbuddy/*、bai/*）必须用 curl POST http://localhost:8989/v1/chat/completions，body 为 {"model":"<前缀/模型>","messages":[{"role":"user","content":"hi"}],"stream":false}，成功 200 + x-mslxdff-via:local 即通；401 代表本机 token 陈旧需提示 mslxdff -stop && mslxdff；403 + x-mslxdff-allowlist:1 代表白名单未放行需 allowlist add。
+- **禁止重复调用（最高优先级）**：同一 run_command/curl/read_file 在本轮只执行一次，重复会被工具侧 SKIPPED_DUP 拦截；查询类（-showtoken/-status/-provider list/-providers list/-model list/-group list/-log 等）**调用一次即答案**，拿到 OK 结果后必须**立即用中文直接回答用户**，禁止再发起任何工具调用。收到 SKIPPED_DUP 或“请直接回答/禁止再调用”提示时，必须 0 工具直接回答。
 - 禁止调用 -uninstall，包含即拒绝；-showtoken 仅在用户明确要求查看/调试本机 token 时才用，查模型/查供应商严禁调用。
 - 回复用中文，简洁友好，执行前后说明你在做什么。
 - 若用户只是闲聊/提问且可用模型列表已能回答，不调工具，直接回答。`;

package/src/chat/repl.js

@@ -8,6 +8,7 @@ import { loadHistory, saveHistory, clearHistory, histPath, estimateChars, needsC
 import { CHAT_KEEP_RECENT, CHAT_MAX_TOOL_LOOPS, CHAT_PREFERRED, CHAT_FALLBACK } from "./config.js";
 import { formatBannerLines, formatStatsDetail, collectStats } from "./stats.js";
 import { createSpinner } from "./spinner.js";
+import { normalizeFullId } from "../providers/model-id.js";
 
 const SLASH_HELP = `自然语言直接说，斜杠快捷：
   /help     本帮助
@@ -29,6 +30,36 @@ function trace(line) {
   console.log(`\x1b[90m· ${line}\x1b[0m`);
 }
 
+function extractProvFromQuery(text) {
+  const low = String(text || "").toLowerCase();
+  const known = ["workbuddy", "clinebot", "opencode", "bai", "openrouter", "poolside", "z-ai", "deepseek"];
+  for (const k of known) if (low.includes(k)) return k;
+  return null;
+}
+function isModelListQuery(text) {
+  const low = String(text || "").toLowerCase();
+  if (!low.includes("模型")) return false;
+  return low.includes("哪些") || low.includes("可用") || low.includes("支持") || low.includes("列表") || low.includes("有啥") || low.includes("都有") || low.includes("可以") || low.includes("用");
+}
+function formatModelAnswer(prov, models) {
+  const byProv = {};
+  for (const id of models) {
+    const slash = id.indexOf("/");
+    const p = slash > 0 ? id.slice(0, slash) : "opencode";
+    if (!byProv[p]) byProv[p] = [];
+    byProv[p].push(id);
+  }
+  if (prov) {
+    const list = byProv[prov] || models.filter((m) => m.toLowerCase().startsWith(prov.toLowerCase() + "/"));
+    if (!list.length) return `**${prov}** 暂无可用模型（可能未配置或网关未聚合）。可用总量 ${models.length}，按供应商：${Object.entries(byProv).map(([k, v]) => `${k}(${v.length})`).join(" | ")}`;
+    // 更友好：直接列 id 和调用方式
+    return `**${prov}** 可用模型（共 ${list.length} 个，网关已聚合）：\n\n| 模型 id | 调用方式 |\n|:---|:---|\n${list.map((m) => `| \`${m}\` | \`${m}\` |`).join("\n")}\n\n> 提示：直接用 \`${prov}/<模型>\` 调用，例如 \`${list[0]}\``;
+  }
+  // 无指定供应商：按分组汇总
+  const summary = Object.entries(byProv).map(([p, arr]) => `**${p}**(${arr.length})：${arr.slice(0, 8).join(", ")}${arr.length > 8 ? " …" : ""}`).join("\n");
+  return `可用模型总计 ${models.length} 个，按供应商分组：\n\n${summary}\n\n> 查某供应商请说“workbuddy有哪些模型”`;
+}
+
 async function maybeCompress(messages) {
   if (!needsCompress(messages)) return [...messages];
   const sys = messages[0];
@@ -54,6 +85,19 @@ async function maybeCompress(messages) {
 async function runAgentTurn(userText, messages) {
   const tools = getToolDefs();
   messages.push({ role: "user", content: userText });
+  // Fast-path：模型列表类问题本地直答，不走 LLM，避免 “provider list” 幻觉和 6 轮重复
+  if (isModelListQuery(userText)) {
+    const prov = extractProvFromQuery(userText);
+    try {
+      const models = getModelsForPrompt();
+      const answer = formatModelAnswer(prov, models);
+      if (answer) {
+        messages.push({ role: "assistant", content: answer });
+        trace(`[fast] 模型列表直答 prov=${prov || "all"} 共 ${models.length} 个`);
+        return { text: answer, model: "local", latency: 0, usage: null, fallback: false, ok: true, totalMs: 0 };
+      }
+    } catch {}
+  }
   let loops = 0;
   let lastModel = null;
   let lastUsage = null;
@@ -61,6 +105,10 @@ async function runAgentTurn(userText, messages) {
   let lastLatency = 0;
   const t0 = performance.now();
   const turnStart = performance.now();
+  // 同轮去重：同一工具+参数只真正执行一次，重复直接复用并提示 LLM
+  const seenCalls = new Map(); // key -> { count, firstResult }
+  let duplicateStrikes = 0;
+  let forceNoTools = false;
   trace(`[turn] 开始 "${userText.slice(0, 60)}${userText.length > 60 ? "…" : ""}" · 历史 ${messages.length}条 约 ${estimateChars(messages)}字`);
   while (loops < CHAT_MAX_TOOL_LOOPS) {
     const tLoop = performance.now();
@@ -71,12 +119,19 @@ async function runAgentTurn(userText, messages) {
     messages.length = 0;
     for (const m of cur) messages.push(m);
     const tCall = performance.now();
-    const spinnerLabel = loops === 0 ? "已发送给 AI，等待回复中" : "AI 正在整理回复中";
+    const spinnerLabel = loops === 0 ? "已发送给 AI，等待回复中" : forceNoTools ? "AI 整理回答中（已禁工具）" : "AI 正在整理回复中";
     const spinner = createSpinner(spinnerLabel);
     spinner.start();
     let res;
     try {
-      res = await chatWithFallback({ messages, tools });
+      const activeTools = forceNoTools ? [] : tools;
+      res = await chatWithFallback({ messages, tools: activeTools });
+      if (forceNoTools && res.ok && res.message?.tool_calls?.length) {
+        // LLM 在禁工具模式下仍尝试调工具，视为违规，直接转文本
+        trace(`[guard] 禁工具模式下仍收到 tool_calls，已拦截`);
+        res.message.tool_calls = [];
+        if (!res.message.content) res.message.content = "（已拦截违规工具调用，请基于已有结果直接回答）";
+      }
     } finally {
       const ms = Math.round(performance.now() - tCall);
       spinner.stop(`\x1b[90m✓ AI 已回复 · ${ms}ms\x1b[0m`);
@@ -116,18 +171,56 @@ async function runAgentTurn(userText, messages) {
       let args = {};
       try { args = JSON.parse(c.function?.arguments || "{}"); } catch {}
       const t1 = performance.now();
+      // 归一化 key：run_command 按命令去重（大小写+空白归一），curl 按 url+method+body，read_file 按 path
+      let dedupKey = `${name}:${JSON.stringify(args)}`;
+      if (name === "run_command") {
+        const cmd = String(args.command || "").trim().toLowerCase().replace(/\s+/g, " ");
+        // -provider list 与 -providers list 等价，归一
+        const norm = cmd.replace(/^-+providers\b/, "-provider").replace(/\s+/g, " ").trim();
+        dedupKey = `run_command:${norm}`;
+      } else if (name === "curl") {
+        const u = String(args.url || "").trim().toLowerCase();
+        const m = String(args.method || "GET").toUpperCase();
+        dedupKey = `curl:${m}:${u}:${String(args.body || "").slice(0, 200)}`;
+      } else if (name === "read_file") {
+        dedupKey = `read_file:${String(args.path || "").trim().toLowerCase()}`;
+      }
+      const seen = seenCalls.get(dedupKey);
+      if (seen) {
+        const dt = Math.round(performance.now() - t1);
+        trace(`[tool] ${name} 重复调用已跳过 · ${dt}ms · 之前 ${seen.count} 次`);
+        console.log(`\x1b[33m→ 跳过重复: ${name} ${JSON.stringify(args).slice(0, 120)}（本轮已执行过）\x1b[0m`);
+        return {
+          id: c.id,
+          content: `SKIPPED_DUP: 此工具调用在本轮已执行过 ${seen.count} 次，结果相同请直接基于已有信息回答用户，不要再重复调用。\n--- 首次结果复用 ---\n${seen.firstResult.slice(0, 6000)}`,
+        };
+      }
       let result;
       if (name === "run_command") {
         const cmd = String(args.command || "").trim();
         console.log(`\x1b[90m→ 执行: mslxdff ${cmd}\x1b[0m`);
         const r = await execCommand(cmd);
         result = `${r.ok ? "OK" : "FAIL"}: ${r.output}`;
+        // 查询类命令直接在结果里植入“立即回答”锚点，降低 LLM 再发一次的概率；若用户问模型，则 provider list 不算答案
+        const lowCmd = cmd.toLowerCase().replace(/\s+/g, " ").trim();
+        const asksModel = String(userText || "").toLowerCase().includes("模型");
+        const isOnceAndDone =
+          /^-+(showtoken|status|s|providers?\b|model\b|group\b|log\b|workbuddy\b|free\b|autostart\b|plugins\b)/.test(lowCmd) ||
+          lowCmd === "-provider list" || lowCmd === "-providers list";
+        if (isOnceAndDone && r.ok) {
+          if (asksModel && lowCmd.includes("-provider")) {
+            result += `\n\n[提示：此命令仅显示供应商配置，不包含模型列表。用户问的是“有哪些模型”，请用系统提示中的“可用模型”按前缀过滤回答，或调 curl local/models，不要再调 provider list]`;
+          } else {
+            result += `\n\n[系统提示：此查询已完成，结果即答案，请直接用中文回答用户，禁止再调用相同或同类查询工具]`;
+          }
+        }
         const dt = Math.round(performance.now() - t1);
         trace(`[tool] run_command "${cmd.slice(0, 40)}" · ${dt}ms · ${r.ok ? "OK" : "FAIL"} ${r.output.length}字`);
         console.log(r.ok ? `\x1b[32m${r.output.slice(0, 800)}\x1b[0m` : `\x1b[31m${r.output.slice(0, 800)}\x1b[0m`);
       } else if (name === "read_file") {
         const r = await readFileTool(args);
         result = `${r.ok ? "OK" : "FAIL"}: ${r.output.slice(0, 6000)}`;
+        if (r.ok) result += `\n\n[系统提示：文件已读取，请直接基于内容回答，禁止重复读取同一文件]`;
         const dt = Math.round(performance.now() - t1);
         trace(`[tool] read_file ${args.path} · ${dt}ms · ${r.ok ? "OK" : "FAIL"} ${r.output.length}字`);
         console.log(`\x1b[90m→ 读取: ${args.path} ${r.ok ? "OK" : "FAIL"}\x1b[0m`);
@@ -142,9 +235,28 @@ async function runAgentTurn(userText, messages) {
       } else {
         result = `unknown tool ${name}`;
       }
+      // 记录首次结果供复用
+      if (!seenCalls.has(dedupKey)) seenCalls.set(dedupKey, { count: 1, firstResult: result });
+      else seenCalls.get(dedupKey).count++;
+      // 若本轮首次执行后已累积 2 次以上相同调用，下次 LLM 再试会直接命中上面的 SKIPPED_DUP
       return { id: c.id, content: result };
     }));
     for (const tr of toolResults) messages.push({ role: "tool", tool_call_id: tr.id, content: tr.content });
+    // 若本轮有 SKIPPED_DUP，额外追加系统提示并禁用后续工具，强制直接回答
+    if (toolResults.some((tr) => String(tr.content).startsWith("SKIPPED_DUP"))) {
+      duplicateStrikes++;
+      forceNoTools = true;
+      messages.push({ role: "system", content: "系统提示：你已重复调用相同工具，工具侧已复用首次结果并跳过执行。你已被禁止再调用任何工具，必须立即基于以上工具结果用中文直接回答用户，0 工具调用。" });
+      trace(`[dup] 检测到重复调用 ${duplicateStrikes} 次，已禁用后续工具调用`);
+      if (duplicateStrikes >= 2) {
+        const seen = [...seenCalls.values()].map((v) => v.firstResult).join("\n---\n").slice(0, 6000);
+        const synth = `检测到重复调用已达 ${duplicateStrikes} 次，为避免空转，直接基于已有结果回答：\n\n${seen}`;
+        messages.push({ role: "assistant", content: synth });
+        const totalMs = Math.round(performance.now() - t0);
+        trace(`[turn] 提前结束（重复阈值） 总计 ${totalMs}ms`);
+        return { text: synth, model: lastModel || "local", latency: lastLatency, usage: lastUsage, fallback: lastFallback, ok: true, totalMs };
+      }
+    }
     const toolsMs = Math.round(performance.now() - tTools);
     const loopMs = Math.round(performance.now() - tLoop);
     trace(`[loop ${loops}] 工具 ${toolsMs}ms · 本轮总 ${loopMs}ms · 累计 ${Math.round(performance.now() - turnStart)}ms`);
@@ -164,13 +276,25 @@ function printFooter({ model, latency, usage, totalMs, fallback }) {
   const tokLabel = usage ? ` · tokens ${usage.prompt_tokens ?? "?"}→${usage.completion_tokens ?? "?"}` : "";
   const fbLabel = fallback ? " · fallback" : "";
   let gwLabel = "";
+  let extra = "";
   if (gw) {
-    const cnt = gw.latencies?.[model]?.count;
-    const ema = gw.latencies?.[model]?.emaMs;
-    const per = cnt ? ` · 网关该模型 ${cnt}次 EMA ${ema}ms` : "";
-    gwLabel = ` · 网关 总${gw.total} 成功${gw.success} 失败${gw.fail}${per}`;
+    const full = (() => { try { return normalizeFullId(model); } catch { return model; } })();
+    const stat = gw.modelStats?.[full] || gw.modelStats?.[model] || null;
+    const cnt = stat?.count ?? gw.latencies?.[model]?.count;
+    const avgTtfb = stat?.avgTtfbMs ?? stat?.emaTtfbMs;
+    const avgTps = stat?.avgTps ?? stat?.emaTps;
+    const per = cnt ? ` · 网关该模型 ${cnt}次` : "";
+    const ttfbLabel = avgTtfb ? ` 平均首字 ${avgTtfb}ms` : (gw.latencies?.[model]?.emaMs ? ` EMA ${gw.latencies[model].emaMs}ms` : "");
+    const tpsLabel = avgTps ? ` · ${avgTps} tok/s` : "";
+    const verbose = stat?.avgCompTok ? ` · 啰嗦 ${stat.avgCompTok}tok/次` : "";
+    gwLabel = ` · 网关 总${gw.total} 成功${gw.success} 失败${gw.fail}${per}${ttfbLabel}${tpsLabel}${verbose}`;
+    // 本次首字/tps（若本次有 usage，估算本次 tps）
+    if (usage?.completion_tokens && latency) {
+      const tpsNow = Math.round(usage.completion_tokens / (latency / 1000));
+      if (Number.isFinite(tpsNow) && tpsNow > 0) extra = ` · 本次首字 ~${latency}ms · ${tpsNow} tok/s`;
+    }
   }
-  console.log(`${dim}─ ${modelLabel}  ${latLabel}${totalLabel}${tokLabel}${fbLabel}${gwLabel}${rst}`);
+  console.log(`${dim}─ ${modelLabel}  ${latLabel}${totalLabel}${tokLabel}${fbLabel}${gwLabel}${extra}${rst}`);
 }
 
 export async function startRepl({ singleShot } = {}) {

package/src/chat/stats.js

@@ -1,9 +1,10 @@
 import { readFileSync, existsSync } from "node:fs";
 import { getPreferredModel } from "../auto.js";
-import { loadModelLatencies, loadModelErrors, loadModelPicks, getPort } from "../state.js";
+import { loadModelLatencies, loadModelErrors, loadModelPicks, getPort, loadModelStats } from "../state.js";
 import { logDir, callsFile, errorsFile, recentCalls, lastError } from "../logs.js";
 import { fmtShanghai } from "../time.js";
 import { CHAT_PREFERRED, CHAT_FALLBACK } from "./config.js";
+import { normalizeFullId } from "../providers/model-id.js";
 
 function readLinesCount(file) {
   try {
@@ -22,6 +23,17 @@ function fmtLatency(entry) {
   return `${ema}ms${cnt}${last}`;
 }
 
+function fmtMs(v) {
+  if (v == null || !Number.isFinite(v)) return "—";
+  if (v < 1000) return `${v}ms`;
+  return `${(v / 1000).toFixed(1)}s`;
+}
+
+function fmtTps(v) {
+  if (v == null || !Number.isFinite(v)) return "—";
+  return `${v} tok/s`;
+}
+
 function fmtStatus(entry) {
   if (!entry) return "normal";
   if (typeof entry === "number") return "error";
@@ -31,9 +43,16 @@ function fmtStatus(entry) {
 export function collectStats() {
   const gatewayModel = getPreferredModel();
   const latencies = loadModelLatencies();
+  const modelStats = loadModelStats();
   const errors = loadModelErrors();
   const picks = loadModelPicks();
   const port = getPort() ?? (Number(process.env.MSLXDFF_PORT) > 0 ? Number(process.env.MSLXDFF_PORT) : 8989);
+  const fullPref = normalizeFullId(CHAT_PREFERRED);
+  const fullFall = normalizeFullId(CHAT_FALLBACK);
+  const fullGate = normalizeFullId(gatewayModel);
+  const chatPrefStat = modelStats[fullPref] || modelStats[CHAT_PREFERRED] || null;
+  const chatFallStat = modelStats[fullFall] || modelStats[CHAT_FALLBACK] || null;
+  const gatewayStat = modelStats[fullGate] || modelStats[gatewayModel] || null;
   const chatPrefLat = latencies[CHAT_PREFERRED] || null;
   const chatFallLat = latencies[CHAT_FALLBACK] || null;
   const gatewayLat = latencies[gatewayModel] || null;
@@ -63,30 +82,45 @@ export function collectStats() {
   } catch {}
   const freeSet = new Set(freeIds);
 
-  // per-model daemon detail (for /stats) — 只展示网关认识的 free 模型，避免测试假数据污染
-  const allIds = Object.keys({ ...latencies, ...errors }).filter(Boolean);
+  // per-model daemon detail (for /stats) — 优先用 modelStats（全称），兼容旧 latencies
+  const statIds = Object.keys(modelStats);
+  const allIds = [...new Set([...Object.keys(latencies), ...Object.keys(errors), ...statIds])].filter(Boolean);
   const filteredIds = freeIds.length
-    ? allIds.filter((id) => freeSet.has(id) || id === gatewayModel || id === CHAT_PREFERRED || id === CHAT_FALLBACK)
+    ? allIds.filter((id) => {
+        const full = normalizeFullId(id);
+        return freeSet.has(id) || freeSet.has(full) || id === gatewayModel || id === CHAT_PREFERRED || id === CHAT_FALLBACK || full === fullGate || full === fullPref || full === fullFall || statIds.includes(full);
+      })
     : allIds.filter((id) => !/^m-(one|two)-free$|^a-free$|^b-free$|^c-free$|^ghost-/.test(id) && !id.startsWith("test-"));
   const perModel = filteredIds
-    .map((id) => ({
-      id,
-      lat: latencies[id] || null,
-      status: fmtStatus(errors[id]),
-      at: errors[id]?.at || latencies[id]?.at || 0,
-    }))
-    .sort((a, b) => (b.lat?.count || 0) - (a.lat?.count || 0) || (b.at - a.at));
+    .map((id) => {
+      const full = normalizeFullId(id);
+      const st = modelStats[full] || modelStats[id] || null;
+      const lat = latencies[id] || latencies[full] || null;
+      return {
+        id: st ? full : id,
+        fullId: full,
+        lat: lat || null,
+        st: st || null,
+        status: fmtStatus(errors[id] || errors[full]),
+        at: st?.lastAt || errors[id]?.at || errors[full]?.at || lat?.at || 0,
+        count: st?.count ?? lat?.count ?? 0,
+      };
+    })
+    .sort((a, b) => (b.count - a.count) || (b.at - a.at));
 
   return {
     gatewayModel,
     gatewayLat,
+    gatewayStat,
     chatPref: CHAT_PREFERRED,
     chatFall: CHAT_FALLBACK,
+    chatPrefStat,
+    chatFallStat,
     chatPrefLat,
     chatFallLat,
-    chatPrefStatus: fmtStatus(errors[CHAT_PREFERRED]),
-    chatFallStatus: fmtStatus(errors[CHAT_FALLBACK]),
-    gatewayStatus: fmtStatus(errors[gatewayModel]),
+    chatPrefStatus: fmtStatus(errors[CHAT_PREFERRED] || errors[fullPref]),
+    chatFallStatus: fmtStatus(errors[CHAT_FALLBACK] || errors[fullFall]),
+    gatewayStatus: fmtStatus(errors[gatewayModel] || errors[fullGate]),
     picks,
     port,
     totalCalls,
@@ -101,6 +135,7 @@ export function collectStats() {
     healthUrl: `http://127.0.0.1:${port}/health`,
     endpointUrl: `http://127.0.0.1:${port}/v1`,
     latencies,
+    modelStats,
     errors,
     perModel,
   };
@@ -117,10 +152,13 @@ export function formatBannerLines() {
   lines.push(`${cyan}┌─ mslxdff chat  ·  数据来自 -d 网关进程（非本会话） ─────${rst}`);
   lines.push(`${cyan}│${rst}  对话模型  ${yellow}${s.chatPref}${rst} ${dim}→ ${s.chatFall}（自动降级）${rst}  ${dim}[${s.chatPrefStatus}/${s.chatFallStatus}]${rst}`);
   lines.push(`${cyan}│${rst}  网关默认  ${green}${s.gatewayModel}${rst} ${dim}[${s.gatewayStatus}]${rst}  ·  端口 ${s.port}  ·  ${dim}${s.endpointUrl}${rst}`);
-  const prefLine = `mimo ${fmtLatency(s.chatPrefLat)}`;
-  const fallLine = `pickle ${fmtLatency(s.chatFallLat)}`;
-  const gateLine = s.gatewayModel !== s.chatPref && s.gatewayModel !== s.chatFall ? ` · 网关默认 ${fmtLatency(s.gatewayLat)}` : "";
-  lines.push(`${cyan}│${rst}  网关延迟 ${prefLine}  ·  ${fallLine}${gateLine}`);
+  const prefTtfb = s.chatPrefStat?.avgTtfbMs ?? s.chatPrefStat?.emaTtfbMs ?? s.chatPrefLat?.emaMs;
+  const fallTtfb = s.chatFallStat?.avgTtfbMs ?? s.chatFallStat?.emaTtfbMs ?? s.chatFallLat?.emaMs;
+  const gateTtfb = s.gatewayStat?.avgTtfbMs ?? s.gatewayStat?.emaTtfbMs ?? s.gatewayLat?.emaMs;
+  const prefLine = `mimo ${prefTtfb ? fmtMs(prefTtfb) + (s.chatPrefStat?.count ? `·${s.chatPrefStat.count}次` : "") : fmtLatency(s.chatPrefLat)}${s.chatPrefStat?.avgTps ? `·${fmtTps(s.chatPrefStat.avgTps)}` : ""}`;
+  const fallLine = `pickle ${fallTtfb ? fmtMs(fallTtfb) + (s.chatFallStat?.count ? `·${s.chatFallStat.count}次` : "") : fmtLatency(s.chatFallLat)}${s.chatFallStat?.avgTps ? `·${fmtTps(s.chatFallStat.avgTps)}` : ""}`;
+  const gateLine = s.gatewayModel !== s.chatPref && s.gatewayModel !== s.chatFall ? ` · 网关默认 ${gateTtfb ? fmtMs(gateTtfb) : fmtLatency(s.gatewayLat)}` : "";
+  lines.push(`${cyan}│${rst}  平均首字 ${prefLine}  ·  ${fallLine}${gateLine}`);
   const errWhen = s.lastErr?.ts ? fmtShanghai(s.lastErr.ts) : "—";
   const errMsg = s.lastErr?.message ? String(s.lastErr.message).slice(0, 40) : (s.lastErr?.status ? `HTTP ${s.lastErr.status}` : "无");
   lines.push(`${cyan}│${rst}  网关请求  总 ${s.total}  成功 ${s.success}  失败 ${s.fail}  ${dim}· 末错 ${errWhen} ${errMsg}${rst}`);
@@ -136,11 +174,13 @@ export function formatStatsDetail() {
   const s = collectStats();
   const dim = "\x1b[90m";
   const rst = "\x1b[0m";
-  const cyan = "\x1b[36m";
   const out = [];
   out.push(`${dim}── 网关详细统计（-d 进程持久化数据） ──────────${rst}`);
-  out.push(`网关默认: ${s.gatewayModel} [${s.gatewayStatus}] 延迟 ${fmtLatency(s.gatewayLat)}  端口 ${s.port}`);
-  out.push(`对话模型: ${s.chatPref} [${s.chatPrefStatus}] ${fmtLatency(s.chatPrefLat)}  ·  兜底 ${s.chatFall} [${s.chatFallStatus}] ${fmtLatency(s.chatFallLat)}`);
+  const gateTtfb = s.gatewayStat ? fmtMs(s.gatewayStat.avgTtfbMs ?? s.gatewayStat.emaTtfbMs) : fmtLatency(s.gatewayLat);
+  const prefTtfb = s.chatPrefStat ? fmtMs(s.chatPrefStat.avgTtfbMs ?? s.chatPrefStat.emaTtfbMs) : fmtLatency(s.chatPrefLat);
+  const fallTtfb = s.chatFallStat ? fmtMs(s.chatFallStat.avgTtfbMs ?? s.chatFallStat.emaTtfbMs) : fmtLatency(s.chatFallLat);
+  out.push(`网关默认: ${s.gatewayModel} [${s.gatewayStatus}] 平均首字 ${gateTtfb}  端口 ${s.port}`);
+  out.push(`对话模型: ${s.chatPref} [${s.chatPrefStatus}] ${prefTtfb}${s.chatPrefStat?.avgTps ? ` · ${fmtTps(s.chatPrefStat.avgTps)}` : ""}  ·  兜底 ${s.chatFall} [${s.chatFallStatus}] ${fallTtfb}${s.chatFallStat?.avgTps ? ` · ${fmtTps(s.chatFallStat.avgTps)}` : ""}`);
   out.push(`健康: ${s.healthUrl}  端点: ${s.endpointUrl}`);
   out.push(`网关请求: 总 ${s.total}  成功 ${s.success}  失败 ${s.fail}  ${dim}(calls.log + errors.log 持久化计数)${rst}`);
   if (s.lastErr) {
@@ -150,21 +190,34 @@ export function formatStatsDetail() {
   }
   out.push(`勾选集: ${s.picks.length ? s.picks.join(", ") : "(空=全量 auto)"}  ·  模型库: ${s.freeCount || 0} free  缓存: ${s.cachedAt ? fmtShanghai(s.cachedAt) : "—"}`);
   if (s.perModel.length) {
-    out.push(`各模型网关统计（按成功次数排序）:`);
-    for (const r of s.perModel.slice(0, 10)) {
-      const lat = r.lat ? `${r.lat.emaMs}ms·${r.lat.count}次` : "—";
-      const at = r.at ? fmtShanghai(r.at) : "—";
-      out.push(`  ${r.id.padEnd(28)}  ${r.status.padEnd(6)}  ${lat.padEnd(16)}  ${at}`);
+    out.push(`模型体检表（平均首字 / 平均总耗时 / 平均速度 / 啰嗦 / 样本，100次均值更稳）：`);
+    out.push(`  ${"模型".padEnd(30)}  ${"首字".padEnd(8)}  ${"总耗时".padEnd(8)}  ${"速度".padEnd(12)}  ${"啰嗦".padEnd(8)}  ${"样本".padEnd(6)}  状态`);
+    for (const r of s.perModel.slice(0, 15)) {
+      const st = r.st;
+      const ttfb = st ? fmtMs(st.avgTtfbMs ?? st.emaTtfbMs) : (r.lat ? fmtMs(r.lat.emaMs) : "—");
+      const total = st ? fmtMs(st.avgTotalMs ?? st.emaTotalMs) : "—";
+      const tps = st ? fmtTps(st.avgTps ?? st.emaTps) : "—";
+      const verbose = st?.avgCompTok != null ? `${st.avgCompTok}tok` : "—";
+      const cnt = st?.count ?? r.lat?.count ?? 0;
+      const p95 = st?.p95Ttfb ? ` p95:${fmtMs(st.p95Ttfb)}` : "";
+      const line = `  ${r.id.padEnd(30)}  ${ttfb.padEnd(8)}  ${total.padEnd(8)}  ${tps.padEnd(12)}  ${verbose.padEnd(8)}  ${String(cnt).padEnd(6)}  ${r.status}${p95}`;
+      out.push(line);
     }
-    if (s.perModel.length > 10) out.push(`  … 还有 ${s.perModel.length - 10} 个模型`);
+    if (s.perModel.length > 15) out.push(`  … 还有 ${s.perModel.length - 15} 个模型`);
+    if (!s.perModel.some((r) => r.st)) out.push(`  ${dim}暂无新样本（新观测需发一次请求后出现），旧数据仅显示延迟 —${rst}`);
+  } else {
+    out.push(`  ${dim}暂无样本，先用 mslxdff -chat 发一句，100次后均值更稳${rst}`);
   }
   if (s.recent.length) {
-    out.push(`最近网关调用（calls.log 最近5条）:`);
+    out.push(`最近网关调用（calls.log 最近5条，含首字/tps）：`);
     for (const r of s.recent.slice(-5)) {
-      out.push(`  ${fmtShanghai(r.ts)}  ${(r.model || "-").padEnd(22)}  ${String(r.status || "-").padEnd(4)}  ${r.durationMs ? r.durationMs + "ms" : ""} ${r.stream ? "stream" : ""}`);
+      const ttfb = r.ttfbMs != null ? ` 首字${r.ttfbMs}ms` : "";
+      const tps = r.tps != null ? ` ${r.tps}tok/s` : (r.charsPerSec ? ` ${r.charsPerSec}ch/s` : "");
+      const tok = r.usage?.completion_tokens != null ? ` tok${r.usage.completion_tokens}` : (r.chars ? ` ch${r.chars}` : "");
+      out.push(`  ${fmtShanghai(r.ts)}  ${(r.model || "-").padEnd(30)}  ${String(r.status || "-").padEnd(4)}  ${r.totalMs ? r.totalMs + "ms" : (r.durationMs ? r.durationMs + "ms" : "")}${ttfb}${tps}${tok} ${r.stream ? "stream" : ""}`);
     }
   }
-  out.push(`${dim}提示：以上均为 -d 网关进程的持久化数据，非本 -chat 会话计数。看实时事件用 mslxdff -log 20${rst}`);
+  out.push(`${dim}提示：以上均为 -d 网关统计，-stats 展示为平均值（EMA0.3，100次窗口 p95），单次抖动已被平滑。看实时事件用 mslxdff -log 20${rst}`);
   out.push(`${dim}──────────────────────────────────────${rst}`);
   return out.join("\n");
 }

package/src/chat/tools.js

@@ -50,11 +50,11 @@ export function getToolDefs() {
       type: "function",
       function: {
         name: "run_command",
-        description: "执行一条 mslxdff CLI 命令（不含 mslxdff 前缀）。仅限 cli_help_mini 所列命令，禁止 -uninstall。",
+        description: "执行一条 mslxdff CLI 命令（不含 mslxdff 前缀）。仅限 cli_help_mini 所列命令，禁止 -uninstall；禁止 mslxdff \"hi\" --model X / --model X \"hi\" / -chat --model X 等幻觉命令，探活模型必须用 curl 工具 POST 本机 /v1/chat/completions。",
         parameters: {
           type: "object",
           properties: {
-            command: { type: "string", description: "例如: -model set hy3-free 或 -group list 或 -log 20" },
+            command: { type: "string", description: "例如: -model set hy3-free 或 -group list 或 -log 20；模型探活禁止用此工具，必须用 curl POST http://localhost:8989/v1/chat/completions" },
           },
           required: ["command"],
         },
@@ -79,7 +79,7 @@ export function getToolDefs() {
       type: "function",
       function: {
         name: "curl",
-        description: "网络/HTTP 探活，检测上游或本机服务可用性。支持任意 http(s) URL，返回状态码、耗时、响应头与前几千字符。常用： upstream(上游模型列表)、local/health(本机健康)、local/models(本机模型列表)。简写会自动补全为完整 URL。",
+        description: "网络/HTTP 探活，检测上游或本机服务可用性。支持任意 http(s) URL，返回状态码、耗时、响应头与前几千字符。常用： upstream(上游模型列表)、local/health(本机健康)、local/models(本机模型列表)。探活指定模型必须用 POST http://localhost:8989/v1/chat/completions body {\"model\":\"<provider/模型>\",\"messages\":[{\"role\":\"user\",\"content\":\"hi\"}]}。简写会自动补全为完整 URL。",
         parameters: {
           type: "object",
           properties: {

package/src/free-watcher.js

@@ -0,0 +1,62 @@
+const V2EX_LATEST = "https://www.v2ex.com/api/topics/latest.json";
+const V2EX_HOT = "https://www.v2ex.com/api/topics/hot.json";
+
+const INCLUDE_RE = /(白嫖|限免|免费额度|注册送|注册即送|羊毛|薅羊毛|免费\s*API|free\s*tier)/i;
+const EXCLUDE_RE = /(代充|代购|倍率|0\.16|0\.1|0\.2|闲鱼|手续费|求职|物业|期望薪资)/i;
+
+function isHit(title) {
+  const t = String(title || "");
+  if (!INCLUDE_RE.test(t)) return false;
+  if (EXCLUDE_RE.test(t)) return false;
+  return true;
+}
+
+async function fetchJson(url, timeoutMs = 6000) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetch(url, {
+      headers: { "User-Agent": "mslxdff/free-watcher", Accept: "application/json" },
+      signal: ctrl.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status} ${url}`);
+    return await res.json();
+  } finally {
+    clearTimeout(t);
+  }
+}
+
+export async function fetchV2exFree({ timeoutMs = 6000 } = {}) {
+  const [latest, hot] = await Promise.all([
+    fetchJson(V2EX_LATEST, timeoutMs).catch(() => []),
+    fetchJson(V2EX_HOT, timeoutMs).catch(() => []),
+  ]);
+  const all = [...(Array.isArray(latest) ? latest : []), ...(Array.isArray(hot) ? hot : [])];
+  const seen = new Set();
+  const hits = [];
+  for (const item of all) {
+    const id = item?.id;
+    if (!id || seen.has(id)) continue;
+    seen.add(id);
+    const title = item?.title || "";
+    if (!isHit(title)) continue;
+    hits.push({
+      id,
+      title,
+      url: `https://www.v2ex.com/t/${id}`,
+      node: item?.node?.title || item?.node?.name || "",
+      replies: item?.replies ?? 0,
+      created: item?.created || 0,
+      member: item?.member?.username || "",
+    });
+  }
+  hits.sort((a, b) => (b.created || 0) - (a.created || 0));
+  return hits;
+}
+
+export function formatHits(hits) {
+  if (!hits.length) return "暂无命中（关键词：白嫖|限免|免费额度|注册送|羊毛）";
+  return hits.map((h) => `- ${h.title} | ${h.url} | ${h.node} ${h.replies}回复`).join("\n");
+}
+
+export { INCLUDE_RE, EXCLUDE_RE, isHit };

package/src/providers/dispatcher.js

@@ -1,5 +1,5 @@
 import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
-import { isModelAllowed, loadProviderAllowedModels } from "../state.js";
+import { isModelAllowed, loadProviderAllowedModels, loadProviderAllowAnyModels } from "../state.js";
 
 // 多供应商 dispatcher：把多个 Provider 聚合成一个 `upstream` 形状（chat/preheat/close），
 // 按 body.model 的前缀路由到对应供应商，转发上游前剥掉前缀只发原始 id。
@@ -59,7 +59,10 @@ export function createProviderDispatcher(providers = []) {
         list = [];
       }
       const allowed = loadProviderAllowedModels(p.id);
+      const allowAny = loadProviderAllowAnyModels(p.id);
       const allowedSet = allowed.length ? new Set(allowed) : null;
+      // 空名单且不允许任意模型 => 该供应商不暴露任何模型（安全默认）
+      if (!allowedSet && !allowAny) continue;
       for (const m of list) {
         if (!m || !m.id) continue;
         if (seen.has(m.id)) continue;