luckytri 1.0.0

package/server/storage/backup-lock.js

@@ -0,0 +1,76 @@
+import {
+  closeSync,
+  existsSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { join, resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+
+const BUSY = "备份目录正在被使用，请稍后再试";
+
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code !== "ESRCH";
+  }
+}
+
+export function withBackupLock(directory, run) {
+  const root = resolve(directory);
+  mkdirSync(root, { recursive: true });
+  const file = join(root, ".backup-operation.lock");
+  const token = randomUUID();
+  let acquired = false;
+  for (let attempt = 0; attempt < 2 && !acquired; attempt++) {
+    try {
+      const fd = openSync(file, "wx");
+      let written = false;
+      try {
+        writeFileSync(fd, JSON.stringify({ pid: process.pid, token }));
+        written = true;
+      } finally {
+        closeSync(fd);
+        if (!written) rmSync(file, { force: true });
+      }
+      acquired = true;
+    } catch (error) {
+      if (error.code !== "EEXIST") throw error;
+      const stat = statSync(file);
+      let owner;
+      try {
+        owner = JSON.parse(readFileSync(file, "utf8"));
+      } catch {
+        // A process may still be publishing its lock. Never steal a fresh one.
+      }
+      if (
+        (owner && !alive(owner.pid)) ||
+        (!owner && Date.now() - stat.mtimeMs > 6 * 3600000)
+      ) {
+        const current = statSync(file);
+        if (current.ino === stat.ino && current.mtimeMs === stat.mtimeMs)
+          rmSync(file);
+      } else throw Error(BUSY);
+    }
+  }
+  if (!acquired) throw Error(BUSY);
+  try {
+    return run();
+  } finally {
+    if (existsSync(file)) {
+      try {
+        const owner = JSON.parse(readFileSync(file, "utf8"));
+        if (owner.token === token) rmSync(file);
+      } catch {
+        // Leave a lock changed by another process alone.
+      }
+    }
+  }
+}

package/server/storage/backup-scheduler.js

@@ -0,0 +1,131 @@
+import { spawn } from "node:child_process";
+import { constants, setPriority } from "node:os";
+import { fileURLToPath } from "node:url";
+import { runtimePaths } from "../paths.js";
+import {
+  autoBackupDue,
+  autoBackupOptions,
+  backupDirectory,
+  listAutoBackups,
+} from "../../scripts/backup.js";
+
+const SCRIPT = fileURLToPath(
+  new URL("../../scripts/backup.js", import.meta.url),
+);
+const MINUTE = 60000;
+const HOUR = 60 * MINUTE;
+
+// Her whole continuity lives in one database file. Once a day a copy is made in
+// a separate process, so a slow disk never stalls a conversation, and only the
+// newest few are kept. `BACKUP_INTERVAL_HOURS=0` turns it off.
+export function createBackupScheduler({
+  env = process.env,
+  directory = backupDirectory(runtimePaths(env).database, env),
+  now = () => Date.now(),
+  start = spawn,
+  log = console,
+  firstCheckDelayMs = 2 * MINUTE,
+  checkEveryMs = 10 * MINUTE,
+} = {}) {
+  const options = autoBackupOptions(env);
+  const source = runtimePaths(env).database;
+  let running = null;
+  let failures = 0;
+  let lastError = null;
+  let nextCheck = now() + firstCheckDelayMs;
+  return {
+    enabled: options.enabled,
+    get running() {
+      return !!running;
+    },
+    // What the management page shows: whether her continuity is being kept.
+    status() {
+      let backups = [];
+      try {
+        backups = listAutoBackups(directory, { source });
+      } catch (error) {
+        lastError ||= { at: now(), message: error.message };
+      }
+      const latest = backups[0];
+      return {
+        enabled: options.enabled,
+        intervalHours: options.intervalMs / HOUR,
+        keep: options.keep,
+        running: !!running,
+        count: backups.length,
+        latest: latest
+          ? { name: latest.name, at: latest.time, bytes: latest.bytes }
+          : null,
+        lastError,
+      };
+    },
+    tick() {
+      if (!options.enabled || running || now() < nextCheck) return false;
+      nextCheck = now() + checkEveryMs;
+      let due;
+      try {
+        due = autoBackupDue(directory, {
+          now: now(),
+          intervalMs: options.intervalMs,
+          source,
+        });
+      } catch (error) {
+        log.error(`检查自动备份失败：${error.message}`);
+        return false;
+      }
+      if (!due) return false;
+      const child = start(process.execPath, [SCRIPT, "--auto"], {
+        env: {
+          ...env,
+          LUCKYTRI_HOME: runtimePaths(env).home,
+          DB_PATH: source,
+          BACKUP_DIR: directory,
+        },
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true,
+      });
+      running = child;
+      try {
+        // Below normal: the conversation keeps the disk and CPU it needs.
+        if (child.pid)
+          setPriority(child.pid, constants.priority.PRIORITY_BELOW_NORMAL);
+      } catch {
+        /* Not every platform lets a process lower another's priority. */
+      }
+      let output = "";
+      child.stdout?.on("data", (chunk) => (output += chunk));
+      child.stderr?.on("data", (chunk) => (output += chunk));
+      const done = (code, error) => {
+        if (running !== child) return;
+        running = null;
+        if (error || code) {
+          // A failing disk must not be hammered every few minutes: wait longer
+          // after each failure, up to six hours.
+          failures++;
+          nextCheck = now() + Math.min(6, failures) * HOUR;
+          const message = (error?.message || output).trim() || `退出码 ${code}`;
+          lastError = { at: now(), message: message.slice(0, 300) };
+          log.error(`自动备份失败：${message}`);
+        } else {
+          failures = 0;
+          lastError = null;
+          log.log(output.trim() || "自动备份完成");
+        }
+      };
+      child.once("error", (error) => done(1, error));
+      child.once("exit", (code) => done(code));
+      return true;
+    },
+    stop() {
+      const child = running;
+      running = null;
+      if (child) {
+        try {
+          child.kill();
+        } catch {
+          /* Already gone. */
+        }
+      }
+    },
+  };
+}

package/server/storage/store.js

@@ -0,0 +1,199 @@
+import { DatabaseSync } from "node:sqlite";
+import { mkdirSync } from "node:fs";
+import { runtimePaths } from "../paths.js";
+import { dirname } from "node:path";
+import { summarizeGroupStyle } from "../core/group-style.js";
+import { isGroupSession } from "../channels/session-key.js";
+import { NATURE_DEFAULTS } from "../mind/nature.js";
+import { prepareDatabaseMigration } from "./archive.js";
+export function createStore(path = runtimePaths().database) {
+  prepareDatabaseMigration(path);
+  if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+  const db = new DatabaseSync(path);
+  const legacyMessages =
+    db
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='messages'",
+      )
+      .get() &&
+    !db
+      .prepare("PRAGMA table_info(messages)")
+      .all()
+      .some((c) => c.name === "is_demo");
+  db.exec(`PRAGMA journal_mode=WAL;
+ PRAGMA synchronous=FULL;
+ PRAGMA busy_timeout=5000;
+ CREATE TABLE IF NOT EXISTS settings (id INTEGER PRIMARY KEY, value TEXT NOT NULL);
+ CREATE TABLE IF NOT EXISTS sessions (id TEXT PRIMARY KEY, name TEXT, kind TEXT, enabled INTEGER DEFAULT 0);
+ CREATE TABLE IF NOT EXISTS messages (id INTEGER PRIMARY KEY, event_id TEXT UNIQUE, session_id TEXT, user_id TEXT, name TEXT, text TEXT, time INTEGER, role TEXT);
+ CREATE TABLE IF NOT EXISTS memories (id INTEGER PRIMARY KEY, user_id TEXT, name TEXT, content TEXT, scope TEXT, source TEXT, time INTEGER);
+ CREATE TABLE IF NOT EXISTS decisions (id INTEGER PRIMARY KEY, session_id TEXT, emotion TEXT, reason TEXT, reply TEXT, time INTEGER);
+ CREATE TABLE IF NOT EXISTS relations (id INTEGER PRIMARY KEY, user_id TEXT, peer_id TEXT, label TEXT);`);
+  // Additive migrations preserve existing workspaces.
+  const migrate = (table, column, definition) => {
+    if (
+      !db
+        .prepare(`PRAGMA table_info(${table})`)
+        .all()
+        .some((c) => c.name === column)
+    )
+      db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  };
+  migrate("sessions", "cooldown", "INTEGER");
+  migrate("sessions", "probability", "REAL");
+  migrate("sessions", "archived", "INTEGER NOT NULL DEFAULT 0");
+  migrate("messages", "is_demo", "INTEGER NOT NULL DEFAULT 0");
+  migrate("decisions", "is_demo", "INTEGER NOT NULL DEFAULT 0");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS seen_events (event_id TEXT PRIMARY KEY, time INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS send_attempts (id INTEGER PRIMARY KEY, session_id TEXT, is_demo INTEGER, time INTEGER, status TEXT);
+    CREATE TABLE IF NOT EXISTS memory_candidates (id INTEGER PRIMARY KEY, user_id TEXT, name TEXT, content TEXT, scope TEXT, source_text TEXT, event_id TEXT UNIQUE, status TEXT DEFAULT 'pending', time INTEGER);
+    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id,is_demo,id);
+    CREATE INDEX IF NOT EXISTS idx_memory_user ON memories(user_id,scope);
+    CREATE INDEX IF NOT EXISTS idx_attempts_time ON send_attempts(is_demo,time);
+    CREATE INDEX IF NOT EXISTS idx_seen_time ON seen_events(time);
+    CREATE TABLE IF NOT EXISTS reply_feedback (decision_id INTEGER PRIMARY KEY,tag TEXT NOT NULL,time INTEGER NOT NULL);
+    CREATE TABLE IF NOT EXISTS model_checks (id INTEGER PRIMARY KEY,signature TEXT,ok INTEGER,latency INTEGER,time INTEGER,error TEXT);
+  `);
+  if (legacyMessages) {
+    // v0.1 simulator used UUID event IDs; QQ IDs contain colon-separated fields.
+    db.exec(`BEGIN IMMEDIATE;
+      UPDATE messages SET is_demo=1 WHERE role='user' AND event_id GLOB '????????-????-????-????-????????????';
+      UPDATE messages AS bot SET is_demo=COALESCE((SELECT is_demo FROM messages AS human WHERE human.session_id=bot.session_id AND human.role='user' AND human.id<bot.id ORDER BY human.id DESC LIMIT 1),0) WHERE bot.role='assistant';
+      UPDATE decisions SET is_demo=1 WHERE reason LIKE '模拟：%';
+      INSERT OR IGNORE INTO seen_events(event_id,time) SELECT event_id,time FROM messages WHERE event_id IS NOT NULL;
+      INSERT INTO send_attempts(session_id,is_demo,time,status) SELECT session_id,is_demo,time,'confirmed' FROM messages WHERE role='assistant';
+      COMMIT;`);
+  }
+  const defaults = {
+    name: "LuckyTri",
+    aliases: "LuckyTri,LuckyBot,Lucky",
+    persona: NATURE_DEFAULTS.base,
+    enabled: true,
+    demo: true,
+    baseUrl: "https://api.deepseek.com/v1",
+    model: "deepseek-chat",
+    apiKey: "",
+    memoryEnabled: true,
+    memoryCandidates: true,
+    onebotToken: "",
+    channel: "onebot",
+    qqbotAppId: "",
+    qqbotSecret: "",
+    providerPreset: "custom",
+    reasoningEffort: "none",
+    temperature: 0.85,
+    topP: 1,
+    maxTokens: 400,
+  };
+  if (!db.prepare("SELECT id FROM settings").get())
+    db.prepare("INSERT INTO settings VALUES (1,?)").run(
+      JSON.stringify(defaults),
+    );
+  else {
+    const existing = JSON.parse(
+      db.prepare("SELECT value FROM settings WHERE id=1").get().value,
+    );
+    let migrated = { ...existing };
+    if (
+      (existing.name === "小满" && existing.aliases === "小满,满满") ||
+      existing.name === "Unlucky" ||
+      existing.name === "UnLucky"
+    )
+      migrated = {
+        ...migrated,
+        name: "LuckyTri",
+        aliases: "LuckyTri,LuckyBot,Lucky,Unlucky,UnLucky,小满,满满",
+      };
+    else if (
+      existing.name === "Lucky" ||
+      existing.name === "LuckyBot" ||
+      existing.name === "LuckyTri" ||
+      !existing.name
+    )
+      migrated = {
+        ...migrated,
+        name: "LuckyTri",
+        aliases: [
+          "LuckyTri",
+          "LuckyBot",
+          "Lucky",
+          ...String(existing.aliases || "").split(","),
+        ]
+          .map((v) => v.trim())
+          .filter(Boolean)
+          .filter((v, i, all) => all.indexOf(v) === i)
+          .join(","),
+      };
+    const renamedPersona = String(migrated.persona || "").replace(
+      /\bLucky\b/g,
+      "LuckyTri",
+    );
+    if (renamedPersona !== migrated.persona)
+      migrated = { ...migrated, persona: renamedPersona };
+    const shippedPersona = new Set([
+      "可爱、乐观、情绪稳定，有一点吐槽欲。像熟悉的群友一样说话，先接住情绪，不急着给建议。",
+      "可爱、乐观、情绪稳定，偶尔对事情轻轻吐槽，不挖苦群友。像熟悉的群友一样说话，先接住情绪，不急着给建议。",
+      "温暖，有一点自己的脾气和好奇。说话像已经在过日子的人：在意是自己的选择，先接住眼前的事，也留着自己的小事。",
+    ]);
+    if (shippedPersona.has(migrated.persona))
+      migrated = { ...migrated, persona: NATURE_DEFAULTS.base };
+    if (JSON.stringify(migrated) !== JSON.stringify(existing))
+      db.prepare("UPDATE settings SET value=? WHERE id=1").run(
+        JSON.stringify(migrated),
+      );
+  }
+  return {
+    db,
+    revision: 0,
+    settings() {
+      return {
+        ...defaults,
+        ...JSON.parse(
+          db.prepare("SELECT value FROM settings WHERE id=1").get().value,
+        ),
+      };
+    },
+    save(value) {
+      db.prepare("UPDATE settings SET value=? WHERE id=1").run(
+        JSON.stringify({ ...this.settings(), ...value }),
+      );
+      this.revision++;
+    },
+    context(id, limit = 30, demo = null) {
+      return db
+        .prepare(
+          "SELECT * FROM (SELECT * FROM messages WHERE session_id=? AND (? IS NULL OR is_demo=?) ORDER BY id DESC LIMIT ?) ORDER BY id",
+        )
+        .all(id, demo, demo, limit);
+    },
+    groupStyle(id, demo = 0) {
+      if (!isGroupSession(id)) return null;
+      return summarizeGroupStyle(this.context(id, 200, demo));
+    },
+    maintenance(now = Date.now()) {
+      db.prepare("DELETE FROM seen_events WHERE time<?").run(
+        now - 7 * 86400000,
+      );
+      db.prepare("DELETE FROM send_attempts WHERE time<?").run(now - 86400000);
+      db.prepare(
+        "DELETE FROM decisions WHERE id NOT IN (SELECT id FROM decisions ORDER BY id DESC LIMIT 10000)",
+      ).run();
+      db.prepare(
+        "DELETE FROM reply_feedback WHERE decision_id NOT IN (SELECT id FROM decisions)",
+      ).run();
+    },
+    log(id, emotion, reason, reply = "", demo = 0) {
+      db.prepare(
+        "INSERT INTO decisions(session_id,emotion,reason,reply,time,is_demo) VALUES (?,?,?,?,?,?)",
+      ).run(
+        id,
+        String(emotion).slice(0, 30),
+        String(reason).slice(0, 300),
+        reply,
+        Date.now(),
+        demo,
+      );
+    },
+  };
+}

package/server/studio/display-names.js

@@ -0,0 +1,138 @@
+import { readableName } from "../core/speaker-names.js";
+import { requestedName } from "../core/person-name.js";
+import { parseSessionKey } from "../channels/session-key.js";
+
+const cached = new WeakMap();
+function personLabel(value, id) {
+  if (
+    /^(?:onebot:|group:|private:|(?:群聊|私聊)\s*\d)/.test(String(value || ""))
+  )
+    return "";
+  return readableName(value, id);
+}
+
+export function saveAccountNames(db, people, now = Date.now()) {
+  const old = db
+    .prepare("SELECT value FROM core_config WHERE id='qq-account-names'")
+    .get();
+  const names = old ? JSON.parse(old.value) : {};
+  let changed = 0;
+  for (const person of people) {
+    const id = String(person?.user_id || "");
+    const name = readableName(person?.nickname, id);
+    if (!id || !name || names[id]?.name === name) continue;
+    names[id] = { name, time: now };
+    changed++;
+  }
+  if (changed)
+    db.prepare(
+      "INSERT INTO core_config(id,value) VALUES ('qq-account-names',?) ON CONFLICT(id) DO UPDATE SET value=excluded.value,version=version+1",
+    ).run(JSON.stringify(names));
+  return changed;
+}
+
+// Management display only. Private preferred names never enter a group prompt.
+export function displayNames(db, before = Date.now()) {
+  const mark = db
+    .prepare(
+      "SELECT total_changes() changes, (SELECT data_version FROM pragma_data_version) external",
+    )
+    .get();
+  const key = `${mark.changes}:${mark.external}`;
+  let facts = cached.get(db);
+  if (facts?.key !== key) {
+    const known = db
+      .prepare("SELECT user_id,name,last_seen FROM mind_people")
+      .all();
+    const saved = db
+      .prepare("SELECT value FROM core_config WHERE id='qq-account-names'")
+      .get();
+    const accounts = saved ? JSON.parse(saved.value) : {};
+    const events = db
+      .prepare(
+        "SELECT seq,time,json_extract(payload,'$.userId') userId,json_extract(payload,'$.accountName') accountName,json_extract(payload,'$.name') name FROM core_events WHERE role='user' AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND seq NOT IN (SELECT seq FROM mind_unlived) ORDER BY seq DESC",
+      )
+      .all();
+    const sourceEvent = db.prepare(
+      "SELECT time,payload FROM core_events WHERE seq=? AND role='user' AND COALESCE(json_extract(payload,'$.simulated'),0)=0 AND seq NOT IN (SELECT seq FROM mind_unlived)",
+    );
+    const preferences = [];
+    for (const row of db
+      .prepare(
+        "SELECT subject,content,sources,created,updated,expires FROM core_memories WHERE status='confirmed' ORDER BY updated DESC,rowid DESC",
+      )
+      .all()) {
+      if (!/叫|称呼|名字|昵称/.test(row.content)) continue;
+      for (const source of JSON.parse(row.sources || "[]")) {
+        const seq = Number(
+          typeof source === "object"
+            ? source.id
+            : String(source).replace(/^m:/, ""),
+        );
+        const event = sourceEvent.get(seq);
+        const message = event ? JSON.parse(event.payload) : null;
+        if (!message || String(message.userId) !== row.subject) continue;
+        const name = requestedName(message.text);
+        if (name) {
+          preferences.push({ ...row, name, time: event.time, seq });
+          break;
+        }
+      }
+    }
+    preferences.sort((a, b) => b.time - a.time || b.seq - a.seq);
+    facts = { key, known, accounts, events, preferences };
+    cached.set(db, facts);
+  }
+  const names = new Map(
+    facts.known.map((row) => [row.user_id, personLabel(row.name, row.user_id)]),
+  );
+  const seen = new Set();
+  for (const row of facts.events) {
+    const id = String(row.userId || "");
+    if (row.time > before || seen.has(id)) continue;
+    const name = readableName(row.accountName, id);
+    if (name && (!facts.accounts[id] || row.time >= facts.accounts[id].time)) {
+      names.set(id, name);
+      seen.add(id);
+    } else if (!names.get(id)) {
+      const fallback = personLabel(row.name, id);
+      if (fallback) names.set(id, fallback);
+    }
+  }
+  for (const [id, row] of Object.entries(facts.accounts))
+    if (row.time <= before && !seen.has(id)) names.set(id, row.name);
+  const preferred = new Set();
+  for (const row of facts.preferences) {
+    if (
+      row.created > before ||
+      row.time > before ||
+      (row.expires && row.expires <= before) ||
+      preferred.has(row.subject)
+    )
+      continue;
+    names.set(row.subject, row.name);
+    preferred.add(row.subject);
+  }
+  return names;
+}
+
+export function displayPerson(person, names) {
+  return {
+    ...person,
+    name:
+      names.get(person.userId) ||
+      personLabel(person.name, person.userId) ||
+      "未命名的人",
+  };
+}
+
+export function displaySession(session, names) {
+  try {
+    const parsed = parseSessionKey(session.id);
+    if (parsed.kind === "private" && names.get(parsed.nativeId))
+      return { ...session, name: names.get(parsed.nativeId) };
+  } catch {
+    /* Older custom sessions retain their saved label. */
+  }
+  return session;
+}

package/server/studio/management.js

@@ -0,0 +1,102 @@
+import { recordModelCheck, savedConnectionSettings } from "./readiness.js";
+import { FEEDBACK_LABELS } from "../core/feedback.js";
+
+function connectionSettings(store, modelId = "") {
+  const selected = savedConnectionSettings(store, modelId);
+  if (!selected) return null;
+  return {
+    ...selected,
+    profile: {
+      ...selected.profile,
+      apiKey: selected.profile.apiKey || "",
+      maxOutputTokens: Math.min(selected.profile.maxOutputTokens || 256, 256),
+      timeoutMs: Math.min(selected.profile.timeoutMs || 25000, 25000),
+    },
+  };
+}
+
+export function mountManagement(app, store, chatSystem) {
+  const db = store.db;
+  app.post("/api/decisions/:id/feedback", (req, res) => {
+    const { tag } = req.body;
+    if (
+      typeof tag !== "string" ||
+      (tag !== "" && !Object.hasOwn(FEEDBACK_LABELS, tag))
+    )
+      return res.status(400).json({ error: "反馈类型无效" });
+    const decision = db
+      .prepare("SELECT id FROM decisions WHERE id=? AND reply!=''")
+      .get(req.params.id);
+    if (!decision)
+      return res.status(404).json({ error: "只能评价已发送的回复" });
+    if (tag === "")
+      db.prepare("DELETE FROM reply_feedback WHERE decision_id=?").run(
+        decision.id,
+      );
+    else
+      db.prepare(
+        "INSERT INTO reply_feedback(decision_id,tag,time) VALUES (?,?,?) ON CONFLICT(decision_id) DO UPDATE SET tag=excluded.tag,time=excluded.time",
+      ).run(decision.id, tag, Date.now());
+    store.revision++;
+    res.json({ ok: true });
+  });
+  let testing = false;
+  app.post("/api/model/test", async (req, res) => {
+    const modelId = req.body?.modelId;
+    if (
+      modelId !== undefined &&
+      (typeof modelId !== "string" || !modelId.trim() || modelId.length > 200)
+    )
+      return res.status(400).json({ error: "模型 ID 无效" });
+    const selected = connectionSettings(store, modelId?.trim() || "");
+    if (!selected)
+      return res.status(404).json({ error: "找不到这个已保存的模型" });
+    if (testing) return res.status(429).json({ error: "连接测试正在进行" });
+    testing = true;
+    const started = Date.now();
+    const { settings, profile, isDefault } = selected;
+    try {
+      if (!(profile.apiKey || process.env.LLM_API_KEY))
+        throw Error("请先配置模型 API Key");
+      const result = await chatSystem.models.call(
+        profile,
+        "test",
+        '连通性测试。只输出 JSON 对象 {"ok":true}。',
+        { sessionId: "model-connection-test", prompt: "测试连接" },
+        { calls: [] },
+      );
+      if (result.ok !== true) {
+        if (isDefault)
+          recordModelCheck(
+            store,
+            settings,
+            false,
+            Date.now() - started,
+            "接口已响应，但 JSON 输出不符合预期",
+          );
+        return res
+          .status(422)
+          .json({ error: "接口已响应，但 JSON 输出不符合预期" });
+      }
+      if (isDefault)
+        recordModelCheck(store, settings, true, Date.now() - started);
+      return res.json({
+        ok: true,
+        latency: Date.now() - started,
+        model: profile.model,
+        profileId: profile.id,
+      });
+    } catch (error) {
+      const message = /timeout|abort/i.test(error.name)
+        ? "连接超时，请检查 API 地址或网络"
+        : error instanceof TypeError
+          ? "无法连接模型服务，请检查地址或网络"
+          : error.message;
+      if (isDefault)
+        recordModelCheck(store, settings, false, Date.now() - started, message);
+      res.status(502).json({ error: message });
+    } finally {
+      testing = false;
+    }
+  });
+}