tt-help-cli-ycl 1.4.21 → 1.4.22

package/src/watch/tag-service.js

@@ -23,8 +23,10 @@ export const COUNTRY_LANG = {
   AT: "de",
 };
 
-export const LLM_URL = "http://82.156.52.214:18000/v1/chat/completions";
-export const LLM_MODEL = "zc-fast";
+// 旧常量保留兼容（外部可能引用），实际调用走 llm-config 动态配置
+export const LLM_URL =
+  process.env.LLM_URL || "http://82.156.52.214:18000/v1/chat/completions";
+export const LLM_MODEL = process.env.LLM_MODEL || "zc-fast";
 
 export function getLang(country) {
   return COUNTRY_LANG[country] || "en";
@@ -33,25 +35,74 @@ export function getLang(country) {
 // ====== LLM 调用 ======
 
 export async function callLLM(prompt, temperature = 0.7) {
-  const apiKey = process.env.APIKEY || "";
-  const { fetch } = await import("undici");
-
-  const response = await fetch(LLM_URL, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model: LLM_MODEL,
-      messages: [{ role: "user", content: prompt }],
-      max_tokens: 1024,
-      temperature,
-    }),
-  });
+  const { getLlmUrl, getLlmApiKey, isAutoMode, getAutoPool } =
+    await import("./llm-config.js");
+  const url = getLlmUrl();
+  const apiKey = getLlmApiKey();
+
+  // auto 模式：依次尝试候选池中的模型
+  const models = isAutoMode() ? getAutoPool() : [null];
+
+  let lastError = "";
+  for (let i = 0; i < models.length; i++) {
+    const model =
+      models[i] !== null
+        ? models[i]
+        : (await import("./llm-config.js")).getLlmModel();
+    const { fetch } = await import("undici");
+
+    console.error(
+      `[callLLM] → ${url} model=${model} (${i + 1}/${models.length})`,
+    );
 
-  const result = await response.json();
-  return result.choices?.[0]?.message?.content || "";
+    let response;
+    try {
+      response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model,
+          messages: [{ role: "user", content: prompt }],
+          max_tokens: 1024,
+          temperature,
+          enable_thinking: false,
+        }),
+      });
+    } catch (e) {
+      lastError = e.message;
+      console.error(`[callLLM] ${model} 网络失败: ${e.message}，尝试下一个`);
+      continue;
+    }
+
+    const status = response.status;
+    const result = await response.json().catch(() => null);
+
+    if (status !== 200 || !result || !result.choices?.[0]?.message?.content) {
+      const errMsg = result?.error?.message || `HTTP ${status}`;
+      lastError = errMsg;
+      console.error(`[callLLM] ${model} 失败: ${errMsg}，尝试下一个`);
+      continue;
+    }
+
+    const content = result.choices[0].message.content;
+    if (i > 0) {
+      console.error(`[callLLM] ✅ auto 切换成功: ${model}`);
+    }
+    // 记录成功的模型，下次优先用它
+    if (isAutoMode()) {
+      const { recordAutoSuccess } = await import("./llm-config.js");
+      recordAutoSuccess(model);
+    }
+    return content;
+  }
+
+  console.error(
+    `[callLLM] ❌ 全部 ${models.length} 个模型均失败，最后错误: ${lastError}`,
+  );
+  return "";
 }
 
 export function normalizeTag(t) {
@@ -750,21 +801,31 @@ export async function discoverTagsForCountry(
   };
 
   let forceNicheSwitch = null;
-  if (health && health.consecutiveLowProductiveRounds >= 2) {
-    // 连续 ≥2 轮 productive=0，强制切换方向
-    // 找出当前 productive tag 覆盖最多的 niche（即当前方向）
+  if (health && health.consecutiveLowProductiveRounds >= 3) {
+    // 连续 >=3 轮 productive=0，强制切换方向
+    // from = LLM 当前正在攻击的 niche（从 discover_log 追踪）
     const currentNiche =
-      nicheRecommendation?.saturated?.[0]?.niche || "marketplace_local";
-    // 找出覆盖最少的 niche 作为新方向
-    const targetNiche = nicheRecommendation?.uncovered?.[0]?.niche || "food";
+      health.currentNiche ||
+      nicheRecommendation?.saturated?.[0]?.niche ||
+      "marketplace_local";
+
+    // to = uncovered 中排除 currentNiche 后的第一个
+    const uncoveredList = nicheRecommendation?.uncovered || [];
+    const nextUncovered = uncoveredList.find((n) => n.niche !== currentNiche);
+    // 如果所有 uncovered 都被排除（极端情况），回退到 uncovered 最后一个
+    const targetNiche =
+      nextUncovered?.niche ||
+      uncoveredList[uncoveredList.length - 1]?.niche ||
+      "food";
+
     forceNicheSwitch = {
       from: currentNiche,
       to: targetNiche,
-      reason: `连续 ${health.consecutiveLowProductiveRounds} 轮无有效产出`,
+      reason: `连续 ${health.consecutiveLowProductiveRounds} 轮无有效产出，当前位置: ${currentNiche}`,
       description: NICHE_CATEGORIES[targetNiche] || targetNiche,
     };
     console.error(
-      `[tag-service] 🔄 ${country} 强制方向切换: ${currentNiche} → ${targetNiche} (原因: 连续${health.consecutiveLowProductiveRounds}轮低效)`,
+      `[tag-service] 🔄 ${country} 强制方向切换: ${currentNiche} -> ${targetNiche} (原因: 连续${health.consecutiveLowProductiveRounds}轮低效, 当前niche=${health.currentNiche || "?"})`,
     );
   }
 
@@ -778,16 +839,17 @@ export async function discoverTagsForCountry(
   }
 
   // ====== 自闭环 Step 3: 动态温度调整 ======
+  // 策略：默认 0.7，卡死时升温打破 LLM 确定性重复
   let temperature = 0.7; // 默认
   if (health) {
-    if (health.healthStatus === "critical") {
-      temperature = 0.3; // 极度保守
+    if (health.consecutiveLowProductiveRounds >= 3) {
+      temperature = 1.0; // 最大随机性，强制探索新空间
+    } else if (health.consecutiveLowProductiveRounds >= 2) {
+      temperature = 0.9; // 较高随机性，打破模式
+    } else if (health.healthStatus === "critical") {
+      temperature = 0.5; // 有问题但还没卡死，略保守
     } else if (health.healthStatus === "warning") {
-      temperature = 0.5; // 较保守
-    }
-    // 连续低效轮时进一步降温，让 LLM 更保守
-    if (health.consecutiveLowProductiveRounds >= 2) {
-      temperature = Math.min(temperature, 0.3);
+      temperature = 0.6;
     }
   }
 
@@ -903,6 +965,7 @@ export async function discoverTagsForCountry(
     country,
     round,
     strategy,
+    niche: niche || forceNicheSwitch?.to || null,
     tagsRaw: deduped,
     tagsGenerated: unique,
     tagsAdded: inserted.length,
@@ -1343,12 +1406,7 @@ export async function reflectAndLearn(store, country) {
     console.error(`  [${rule.ruleType}] ${rule.ruleText}`);
   }
 
-  // Step 6: 废弃旧规则，写入新规则
-  const supersedeResult = supersedeRules(country, "new reflection round");
-  console.error(
-    `[reflection] ${country} 废弃 ${supersedeResult.superseded} 条旧规则`,
-  );
-
+  // Step 6: 废弃旧规则（带相似度去重），写入新规则
   const rulesToInsert = reflection.rules.map((r) => ({
     country,
     ruleType: r.ruleType,
@@ -1359,6 +1417,26 @@ export async function reflectAndLearn(store, country) {
     analysisSummary: reflection.analysisSummary,
   }));
 
+  const supersedeResult = supersedeRules(
+    country,
+    rulesToInsert,
+    "new reflection round",
+  );
+  if (supersedeResult.skipped) {
+    console.error(
+      `[reflection] ${country} 跳过反思（规则与上次高度相似），不写入新规则`,
+    );
+    return {
+      reflected: true,
+      rulesAdded: 0,
+      analysis: reflection.analysisSummary,
+      skipped: "rules too similar to previous reflection",
+    };
+  }
+  console.error(
+    `[reflection] ${country} 废弃 ${supersedeResult.superseded} 条旧规则`,
+  );
+
   const insertResult = insertReflectionRules(rulesToInsert);
   console.error(
     `[reflection] ${country} 写入 ${insertResult.inserted} 条新规则`,