tt-help-cli-ycl 1.4.21 → 1.4.23

package/src/watch/db-tags.js

@@ -50,11 +50,59 @@ export function insertTag(tag, countries, source = "llm") {
   }
 }
 
+/**
+ * 批量插入 tag，只插入不存在的（INSERT OR IGNORE）。
+ * 用于非 LLM 来源（如视频页采集），不覆盖已有 tag 的任何字段。
+ *
+ * @param {string[]} tags - 原始 tag 名列表（可带 # 前缀）
+ * @param {string[]} countries - 国家列表
+ * @param {string} source - 来源标识，默认 'video'
+ * @returns {{ inserted: number, tags: string[] }}
+ */
+export function insertTagsIfNew(tags, countries, source = "video") {
+  const db = getDb();
+  if (!db) return { inserted: 0, tags: [] };
+  if (!Array.isArray(tags) || tags.length === 0)
+    return { inserted: 0, tags: [] };
+  if (!Array.isArray(countries) || countries.length === 0)
+    return { inserted: 0, tags: [] };
+
+  const normalizedList = tags
+    .map((t) => t.replace(/^#+/, "").trim().toLowerCase())
+    .filter((t) => t.length >= 2);
+
+  if (normalizedList.length === 0) return { inserted: 0, tags: [] };
+
+  const countriesJson = JSON.stringify(countries);
+  let inserted = 0;
+  const insertedTags = [];
+
+  try {
+    const stmt = db.prepare(
+      `INSERT OR IGNORE INTO tags (tag, countries, source) VALUES (?, ?, ?)`,
+    );
+    const txn = db.transaction((items) => {
+      for (const tag of items) {
+        const result = stmt.run(tag, countriesJson, source);
+        if (result.changes > 0) {
+          inserted++;
+          insertedTags.push(tag);
+        }
+      }
+    });
+    txn(normalizedList);
+    return { inserted, tags: insertedTags };
+  } catch (e) {
+    return { inserted, error: e.message };
+  }
+}
+
 export function getTagsByStatus(
   status,
   limit = 100,
   offset = 0,
   country = null,
+  search = null,
 ) {
   const db = getDb();
   if (!db) return [];
@@ -64,6 +112,10 @@ export function getTagsByStatus(
     sql += " AND countries LIKE ?";
     params.push(`%"${country}"%`);
   }
+  if (search) {
+    sql += " AND tag LIKE ?";
+    params.push(`%${search}%`);
+  }
   sql +=
     " ORDER BY refreshed_at DESC NULLS LAST, score ASC, created_at ASC LIMIT ? OFFSET ?";
   params.push(limit, offset);
@@ -71,21 +123,29 @@ export function getTagsByStatus(
   return rows.map(parseTagRow);
 }
 
-export function getTagStats(country = null) {
+export function getTagStats(country = null, search = null) {
   const db = getDb();
   if (!db) return null;
+  const conditions = [];
+  const params = [];
+  if (country) {
+    conditions.push("countries LIKE ?");
+    params.push(`%"${country}"%`);
+  }
+  if (search) {
+    conditions.push("tag LIKE ?");
+    params.push(`%${search}%`);
+  }
+  const whereClause =
+    conditions.length > 0 ? " WHERE " + conditions.join(" AND ") : "";
+
   let sql = `SELECT
     COUNT(*) as total,
     SUM(CASE WHEN status = 'productive' THEN 1 ELSE 0 END) as productive,
     SUM(CASE WHEN status = 'dead' THEN 1 ELSE 0 END) as dead,
     SUM(CASE WHEN status = 'new' THEN 1 ELSE 0 END) as newCount,
     SUM(CASE WHEN status = 'scoring' THEN 1 ELSE 0 END) as scoring
-  FROM tags`;
-  const params = [];
-  if (country) {
-    sql += " WHERE countries LIKE ?";
-    params.push(`%"${country}"%`);
-  }
+  FROM tags${whereClause}`;
   const row = db.prepare(sql).get(...params);
   // 获取所有出现过的国家
   const allRows = db.prepare("SELECT countries FROM tags").all();
@@ -276,15 +336,28 @@ export function reportTagScore(tag, fields) {
   }
 }
 
-export function getAllTags(limit = 200, offset = 0, country = null) {
+export function getAllTags(
+  limit = 200,
+  offset = 0,
+  country = null,
+  search = null,
+) {
   const db = getDb();
   if (!db) return [];
   let sql = "SELECT * FROM tags";
   const params = [];
+  const conditions = [];
   if (country) {
-    sql += " WHERE countries LIKE ?";
+    conditions.push("countries LIKE ?");
     params.push(`%"${country}"%`);
   }
+  if (search) {
+    conditions.push("tag LIKE ?");
+    params.push(`%${search}%`);
+  }
+  if (conditions.length > 0) {
+    sql += " WHERE " + conditions.join(" AND ");
+  }
   sql +=
     " ORDER BY refreshed_at DESC NULLS LAST, score DESC, created_at DESC LIMIT ? OFFSET ?";
   params.push(limit, offset);
@@ -371,6 +444,7 @@ export function insertDiscoverLog({
   country,
   round,
   strategy,
+  niche,
   tagsGenerated,
   tagsRaw,
   tagsAdded,
@@ -382,18 +456,26 @@ export function insertDiscoverLog({
   const db = getDb();
   if (!db) return { ok: false, error: "db not ready" };
 
+  // 确保 niche 列存在（兼容旧表）
+  try {
+    db.prepare("ALTER TABLE discover_log ADD COLUMN niche TEXT").run();
+  } catch {
+    // 列已存在则忽略
+  }
+
   try {
     const result = db
       .prepare(
         `INSERT INTO discover_log
-         (country, round, strategy, tags_generated, tags_raw, tags_added,
+         (country, round, strategy, niche, tags_generated, tags_raw, tags_added,
           productive_sample, dead_sample, avg_productive_score, avg_dead_score)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       )
       .run(
         country,
         round,
         strategy || null,
+        niche || null,
         JSON.stringify(tagsGenerated || []),
         tagsRaw ? JSON.stringify(tagsRaw) : null,
         tagsAdded || 0,
@@ -714,6 +796,9 @@ export function getCountryHealth(country) {
   // 推荐的 niche 方向（基于现有 productive tag 的分类分析）
   const nicheRecommendation = recommendNiche(country, productive);
 
+  // 追踪 LLM 当前在攻击哪个 niche（取最近3轮 discover_log 的 niche 字段，众数）
+  const currentNiche = getCurrentNiche(country);
+
   return {
     country,
     total,
@@ -732,9 +817,43 @@ export function getCountryHealth(country) {
     healthStatus,
     issues,
     nicheRecommendation,
+    currentNiche,
   };
 }
 
+/**
+ * 获取 LLM 当前正在攻击的 niche（最近3轮 discover_log 的 niche 众数）
+ */
+function getCurrentNiche(country) {
+  const db = getDb();
+  if (!db) return null;
+
+  try {
+    const rows = db
+      .prepare(
+        `SELECT niche FROM discover_log
+         WHERE country = ? AND niche IS NOT NULL
+         ORDER BY round DESC
+         LIMIT 3`,
+      )
+      .all(country);
+
+    if (rows.length === 0) return null;
+
+    // 取出现次数最多的 niche
+    const counts = {};
+    for (const r of rows) {
+      const n = r.niche;
+      if (n) counts[n] = (counts[n] || 0) + 1;
+    }
+    const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
+    return sorted.length > 0 ? sorted[0][0] : null;
+  } catch {
+    // niche 列尚不存在（旧表），返回 null
+    return null;
+  }
+}
+
 /**
  * 基于现有 productive tag 推荐新的 niche 方向
  * 分析已有 tag 的类别分布，找出未覆盖或覆盖不足的方向
@@ -1121,13 +1240,68 @@ export function insertReflectionRules(rules) {
   return { ok: true, inserted: inserted.length };
 }
 
+/**
+ * 计算两段规则文本的相似度（简单的词重叠率）
+ * 返回 0-1，越高越相似
+ */
+function ruleTextSimilarity(a, b) {
+  const wordsA = new Set(
+    a
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 2),
+  );
+  const wordsB = new Set(
+    b
+      .toLowerCase()
+      .split(/\s+/)
+      .filter((w) => w.length > 2),
+  );
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+  const intersection = [...wordsA].filter((w) => wordsB.has(w)).length;
+  return intersection / Math.max(wordsA.size, wordsB.size);
+}
+
 /**
  * 废弃旧规则（当新反思覆盖旧规则时）
+ * 加入去重：如果新规则与旧规则语义相似（>70% 词重叠），跳过 supersede
  */
-export function supersedeRules(country, reason = "new reflection") {
+export function supersedeRules(
+  country,
+  newRules = [],
+  reason = "new reflection",
+) {
   const db = getDb();
   if (!db) return { ok: false, error: "db not ready" };
 
+  // 获取当前活跃规则
+  const oldRules = db
+    .prepare(
+      "SELECT id, rule_text FROM reflection_rules WHERE country = ? AND is_active = 1",
+    )
+    .all(country);
+
+  // 规则去重：如果所有新规则与所有旧规则高度相似，跳过
+  if (oldRules.length > 0 && newRules.length > 0) {
+    let allSimilar = true;
+    for (const nr of newRules) {
+      const newText = typeof nr === "string" ? nr : nr.ruleText || "";
+      const hasSimilar = oldRules.some(
+        (or) => ruleTextSimilarity(newText, or.rule_text) > 0.7,
+      );
+      if (!hasSimilar) {
+        allSimilar = false;
+        break;
+      }
+    }
+    if (allSimilar) {
+      console.error(
+        `[reflection] 跳过 supersede: ${newRules.length} 条新规则与 ${oldRules.length} 条旧规则高度相似`,
+      );
+      return { ok: true, superseded: 0, skipped: "rules too similar" };
+    }
+  }
+
   const result = db
     .prepare(
       `UPDATE reflection_rules
@@ -1141,13 +1315,45 @@ export function supersedeRules(country, reason = "new reflection") {
 
 /**
  * 检查是否需要触发反思
- * 条件：最近 N 轮 productive_cnt ≤ threshold
+ * 条件：最近 N 轮 productive_cnt ≤ threshold，且距上次反思 ≥ cooldownRounds 轮
  * @returns {{ shouldReflect: boolean, reason: string, recentRounds: array }}
  */
-export function shouldTriggerReflection(country, lookback = 5, threshold = 1) {
+export function shouldTriggerReflection(
+  country,
+  lookback = 5,
+  threshold = 1,
+  cooldownRounds = 10,
+) {
   const db = getDb();
   if (!db) return { shouldReflect: false, reason: "db not ready" };
 
+  // 冷却期检查：距上次反思不足 cooldownRounds 轮则跳过
+  const lastReflection = db
+    .prepare(
+      `SELECT MAX(rr.created_at) as lastReflectAt
+       FROM reflection_rules rr
+       WHERE rr.country = ? AND rr.is_active = 0 AND rr.superseded_at IS NOT NULL
+       ORDER BY rr.superseded_at DESC
+       LIMIT 1`,
+    )
+    .get(country);
+
+  if (lastReflection?.lastReflectAt) {
+    const roundsSince = db
+      .prepare(
+        `SELECT COUNT(*) as cnt FROM discover_log
+         WHERE country = ? AND created_at > ?`,
+      )
+      .get(country, lastReflection.lastReflectAt);
+    if ((roundsSince?.cnt || 0) < cooldownRounds) {
+      return {
+        shouldReflect: false,
+        reason: `冷却期: 距上次反思仅${roundsSince?.cnt || 0}轮，需≥${cooldownRounds}轮`,
+        recentRounds: [],
+      };
+    }
+  }
+
   // 获取最近 lookback 轮的 discover_log
   const recentLogs = db
     .prepare(
@@ -1202,14 +1408,14 @@ export function shouldTriggerReflection(country, lookback = 5, threshold = 1) {
   }
 
   const avgProductive = totalProductive / lookback;
-  // 触发条件：平均 productive ≤ threshold，或连续 ≥2 轮 productive ≤ 1
+  // 触发条件：平均 productive ≤ threshold，或连续 ≥3 轮 productive ≤ 1
   const shouldReflect =
-    avgProductive <= threshold || consecutiveLowProductiveRounds >= 2;
+    avgProductive <= threshold || consecutiveLowProductiveRounds >= 3;
 
   return {
     shouldReflect,
     reason: shouldReflect
-      ? consecutiveLowProductiveRounds >= 2
+      ? consecutiveLowProductiveRounds >= 3
         ? `连续${consecutiveLowProductiveRounds}轮productive≤1，需要反思换方向`
         : `最近${lookback}轮平均productive=${avgProductive.toFixed(1)} ≤ ${threshold}`
       : `最近${lookback}轮平均productive=${avgProductive.toFixed(1)} > ${threshold}`,
@@ -1222,6 +1428,20 @@ export function shouldTriggerReflection(country, lookback = 5, threshold = 1) {
   };
 }
 
+/**
+ * 清理所有已废弃的反思规则（is_active=0）
+ */
+export function cleanupInactiveReflectionRules() {
+  const db = getDb();
+  if (!db) return { ok: false, error: "db not ready" };
+
+  const result = db
+    .prepare("DELETE FROM reflection_rules WHERE is_active = 0")
+    .run();
+  console.error(`[reflection] 🧹 清理了 ${result.changes} 条废弃规则`);
+  return { ok: true, deleted: result.changes };
+}
+
 /**
  * 获取反思所需的数据摘要（供 LLM 分析）
  */

package/src/watch/llm-config.js

@@ -0,0 +1,319 @@
+/**
+ * LLM 配置持久化模块
+ *
+ * 运行时动态读写 LLM 配置（Provider、Model、URL、APIKey），
+ * 优先从 SQLite 读取，fallback 到环境变量。
+ * 通过 API 修改后立即生效，无需重启。
+ *
+ * 结构：Provider（服务商） → Models（模型列表）
+ * 选择 Provider 自动填入对应 URL，选择 Model 使用对应 model id。
+ */
+
+import { getDb } from "./db-schema.js";
+
+// ====== Provider + Model 定义 ======
+
+export const LLM_PROVIDERS = [
+  {
+    id: "legacy",
+    name: "旧 LLM (zc-fast)",
+    url: "http://82.156.52.214:18000/v1/chat/completions",
+    models: [{ id: "zc-fast", label: "zc-fast" }],
+  },
+  {
+    id: "dashscope",
+    name: "阿里云 DashScope",
+    url: "https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions",
+    models: [
+      { id: "auto", label: "🤖 自动（程序选择）" },
+      { id: "qwen3.7-max", label: "Qwen3.7-Max" },
+      { id: "qwen3.7-max-2026-06-08", label: "Qwen3.7-Max-2026-06-08" },
+      { id: "qwen3.7-max-2026-05-20", label: "Qwen3.7-Max-2026-05-20" },
+      { id: "qwen3.7-max-2026-05-17", label: "Qwen3.7-Max-2026-05-17" },
+      { id: "qwen3.7-max-preview", label: "Qwen3.7-Max-Preview" },
+      { id: "qwen3.7-plus", label: "Qwen3.7-Plus" },
+      { id: "qwen3.7-plus-2026-05-26", label: "Qwen3.7-Plus-2026-05-26" },
+      { id: "qwen3.6-plus", label: "Qwen3.6-Plus" },
+      { id: "qwen3.6-plus-2026-04-02", label: "Qwen3.6-Plus-2026-04-02" },
+      { id: "qwen3.6-max-preview", label: "Qwen3.6-Max-Preview" },
+      { id: "qwen3.6-flash", label: "Qwen3.6-Flash" },
+      { id: "qwen3.6-flash-2026-04-16", label: "Qwen3.6-Flash-2026-04-16" },
+      { id: "qwen3.6-35b-a3b", label: "Qwen3.6-35B-A3B" },
+      { id: "qwen3.6-27b", label: "Qwen3.6-27B" },
+      { id: "qwen3.5-plus", label: "Qwen3.5-Plus" },
+      { id: "qwen3.5-plus-2026-04-20", label: "Qwen3.5-Plus-2026-04-20" },
+      { id: "qwen3.5-ocr", label: "Qwen3.5-OCR" },
+      { id: "qwen-plus", label: "Qwen-Plus" },
+      { id: "qwen-turbo", label: "Qwen-Turbo（即将下线）" },
+      { id: "qwen-max", label: "Qwen-Max" },
+      { id: "deepseek-v4-flash", label: "DeepSeek-V4-Flash" },
+      { id: "deepseek-v4-pro", label: "DeepSeek-V4-Pro" },
+      { id: "glm-5.2", label: "GLM-5.2" },
+      { id: "kimi-k2.7-code", label: "Kimi-K2.7-Code" },
+      { id: "kimi-k2.6", label: "Kimi-K2.6" },
+    ],
+  },
+];
+
+/** 根据 providerId 查找 provider */
+export function findProvider(providerId) {
+  return LLM_PROVIDERS.find((p) => p.id === providerId) || LLM_PROVIDERS[0];
+}
+
+/** 根据 providerId + modelId 查找模型 */
+export function findModel(providerId, modelId) {
+  const provider = findProvider(providerId);
+  return provider.models.find((m) => m.id === modelId) || provider.models[0];
+}
+
+// 兼容旧接口：扁平模型选项列表
+export const LLM_MODEL_OPTIONS = LLM_PROVIDERS.flatMap((p) =>
+  p.models.map((m) => ({
+    id: m.id,
+    label: `${m.label} (${p.name})`,
+    url: p.url,
+  })),
+);
+
+// ====== 内存缓存 ======
+
+let _cachedProvider = null;
+let _cachedModel = null;
+let _cachedUrl = null;
+let _cachedApiKey = null;
+let _loaded = false;
+
+function ensureTable() {
+  const db = getDb();
+  if (!db) return;
+  db.prepare(
+    `CREATE TABLE IF NOT EXISTS _llm_config (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )`,
+  ).run();
+}
+
+function loadFromDb() {
+  const db = getDb();
+  if (!db) return {};
+  ensureTable();
+  try {
+    const rows = db.prepare("SELECT key, value FROM _llm_config").all();
+    const config = {};
+    for (const row of rows) {
+      config[row.key] = row.value;
+    }
+    return config;
+  } catch {
+    return {};
+  }
+}
+
+function saveToDb(key, value) {
+  const db = getDb();
+  if (!db) return;
+  ensureTable();
+  db.prepare(
+    `INSERT INTO _llm_config (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`,
+  ).run(key, String(value));
+}
+
+/**
+ * 加载配置（服务启动时调用一次）
+ * 优先级：SQLite > 环境变量 > 默认值
+ */
+export function loadLlmConfig() {
+  if (_loaded) return;
+  const dbConfig = loadFromDb();
+
+  _cachedUrl = dbConfig.llm_url || process.env.LLM_URL || LLM_PROVIDERS[0].url;
+  _cachedModel =
+    dbConfig.llm_model ||
+    process.env.LLM_MODEL ||
+    LLM_PROVIDERS[0].models[0].id;
+  _cachedProvider = dbConfig.llm_provider || LLM_PROVIDERS[0].id;
+  // 按 provider 隔离读取 API Key：优先 llm_apikey_{provider}，兼容旧 llm_apikey，最后 env
+  _cachedApiKey =
+    dbConfig[`llm_apikey_${_cachedProvider}`] ||
+    dbConfig.llm_apikey ||
+    process.env.APIKEY ||
+    "";
+  _loaded = true;
+
+  console.error(
+    `[llm-config] 加载完成: provider=${_cachedProvider}, model=${_cachedModel}, url=${_cachedUrl}, hasKey=${!!_cachedApiKey}`,
+  );
+}
+
+/**
+ * 获取当前 LLM 配置（供前端 API 使用）
+ */
+export function getLlmConfig() {
+  if (!_loaded) loadLlmConfig();
+  return {
+    provider: _cachedProvider,
+    model: _cachedModel,
+    url: _cachedUrl,
+    hasApiKey: !!_cachedApiKey,
+    apiKeyHint: _cachedApiKey
+      ? _cachedApiKey.slice(0, 6) + "..." + _cachedApiKey.slice(-4)
+      : "",
+  };
+}
+
+/** 获取当前 LLM URL（内部调用） */
+export function getLlmUrl() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedUrl;
+}
+
+// Auto 模式的候选模型池缓存（从 DashScope provider 动态构建，排除 auto 自身）
+let _autoPoolCache = null;
+
+/** 从 DashScope provider 动态构建 auto 候选池（按优先级：flash/turbo > plus > 27b/35b > max/pro > 第三方） */
+function buildAutoPool() {
+  if (_autoPoolCache) return _autoPoolCache;
+  const dashscope = LLM_PROVIDERS.find((p) => p.id === "dashscope");
+  if (!dashscope) return [];
+  const models = dashscope.models.filter((m) => m.id !== "auto");
+
+  const priority = (id) => {
+    if (/flash|turbo/i.test(id)) return 0;
+    if (/plus/i.test(id)) return 1;
+    if (/27b|35b/i.test(id)) return 2;
+    if (/max|pro/i.test(id)) return 3;
+    return 4; // deepseek, glm, kimi 等第三方
+  };
+
+  // 记录原始顺序，排序时优先按 capability tier，同 tier 保持原始顺序
+  const indexed = models.map((m, i) => ({ id: m.id, idx: i }));
+  indexed.sort((a, b) => {
+    const pa = priority(a.id);
+    const pb = priority(b.id);
+    if (pa !== pb) return pa - pb;
+    return a.idx - b.idx;
+  });
+
+  _autoPoolCache = indexed.map((m) => m.id);
+  console.error(
+    `[llm-config] auto 候选池已构建: ${_autoPoolCache.length} 个模型（${_autoPoolCache.slice(0, 5).join(", ")}...）`,
+  );
+  return _autoPoolCache;
+}
+
+/** 清除 auto 候选池缓存（provider 变更后调用） */
+function clearAutoPoolCache() {
+  _autoPoolCache = null;
+}
+
+let _lastAutoSuccess = null; // 上次成功的模型，下次优先用它
+
+/** 是否处于 auto 模式 */
+export function isAutoMode() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedModel === "auto";
+}
+
+/** 记录 auto 模式下成功调用的模型 */
+export function recordAutoSuccess(model) {
+  _lastAutoSuccess = model;
+}
+
+/** 获取 auto 模式候选池（上次成功的排最前，失败时依次尝试） */
+export function getAutoPool() {
+  const pool = [...buildAutoPool()];
+  if (_lastAutoSuccess) {
+    const idx = pool.indexOf(_lastAutoSuccess);
+    if (idx > 0) {
+      // 把上次成功的移到第一位，其余保持相对顺序
+      pool.splice(idx, 1);
+      pool.unshift(_lastAutoSuccess);
+    }
+  }
+  return pool;
+}
+
+/** 解析当前实际使用的 model（auto 模式下轮询选一个） */
+function resolveModel() {
+  if (_cachedModel !== "auto") return _cachedModel;
+  const pool = buildAutoPool();
+  const idx = _autoRoundIdx % pool.length;
+  _autoRoundIdx++;
+  return pool[idx];
+}
+
+/** 获取当前 LLM Model（内部调用，auto 模式自动轮询） */
+export function getLlmModel() {
+  if (!_loaded) loadLlmConfig();
+  return resolveModel();
+}
+
+/** 获取当前 API Key（内部调用） */
+export function getLlmApiKey() {
+  if (!_loaded) loadLlmConfig();
+  return _cachedApiKey;
+}
+
+/**
+ * 更新 LLM 配置（通过 API 调用）
+ * @param {{ provider?: string, model?: string, url?: string, apiKey?: string }} updates
+ */
+export function updateLlmConfig(updates = {}) {
+  if (!_loaded) loadLlmConfig();
+
+  // Provider 变更：切换 URL，Model 用指定的或默认第一个，同时加载对应 provider 的 API Key
+  if (updates.provider !== undefined) {
+    const provider = findProvider(updates.provider);
+    const prevProvider = _cachedProvider;
+    _cachedProvider = provider.id;
+    _cachedUrl = provider.url;
+    clearAutoPoolCache(); // provider 变了，auto 候选池也需重建
+    // 如果同时传了 model 且在 provider 中存在，用指定的；否则用第一个
+    const specifiedModel =
+      updates.model !== undefined
+        ? provider.models.find((m) => m.id === updates.model)
+        : null;
+    _cachedModel = specifiedModel ? specifiedModel.id : provider.models[0].id;
+    // 切换到新 provider：从 DB 加载该 provider 的 API Key
+    if (provider.id !== prevProvider) {
+      const dbConfig = loadFromDb();
+      _cachedApiKey =
+        dbConfig[`llm_apikey_${provider.id}`] ||
+        dbConfig.llm_apikey ||
+        process.env.APIKEY ||
+        "";
+      console.error(
+        `[llm-config] 切换到 ${provider.id}，API Key: ${_cachedApiKey ? "已加载" : "未设置"}`,
+      );
+    }
+    saveToDb("llm_provider", provider.id);
+    saveToDb("llm_url", provider.url);
+    saveToDb("llm_model", _cachedModel);
+  } else if (updates.model !== undefined) {
+    // Model 单独变更（同 provider 内切换）
+    _cachedModel = updates.model;
+    saveToDb("llm_model", updates.model);
+  }
+
+  // URL 手动覆盖
+  if (updates.url !== undefined) {
+    _cachedUrl = updates.url;
+    saveToDb("llm_url", updates.url);
+  }
+
+  // API Key（按 provider 隔离存储，跳过提示字符串）
+  if (updates.apiKey !== undefined && updates.apiKey !== "") {
+    const isHint = updates.apiKey.includes("...") && updates.apiKey.length < 20;
+    if (!isHint) {
+      _cachedApiKey = updates.apiKey;
+      saveToDb(`llm_apikey_${_cachedProvider}`, updates.apiKey);
+    }
+  }
+
+  console.error(
+    `[llm-config] 配置已更新: provider=${_cachedProvider}, model=${_cachedModel}, url=${_cachedUrl}, hasKey=${!!_cachedApiKey}`,
+  );
+
+  return getLlmConfig();
+}