mslxdff 0.1.27 → 0.1.28

package/bin/mslxdff.js

@@ -587,6 +587,7 @@ const models = createModelsService({
 });
 const auto = createAutoSelector({
   cooldownMs: modelCooldownMs(),
+  slowCooldownMs: slowCooldownMs(),
   loadCandidates: async () => {
     try {
       return (await models.get()).data.map((m) => m.id);
@@ -686,6 +687,11 @@ function modelCooldownMs() {
   return Number.isInteger(n) && n > 0 ? n : 60_000;
 }
 
+function slowCooldownMs() {
+  const n = Number(process.env.MSLXDFF_SLOW_COOLDOWN_MS);
+  return Number.isInteger(n) && n > 0 ? n : 5 * 60_000;
+}
+
 function peerCooldownMs() {
   const n = Number(process.env.MSLXDFF_PEER_COOLDOWN_MS);
   return Number.isInteger(n) && n > 0 ? n : 30_000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mslxdff",
-  "version": "0.1.27",
+  "version": "0.1.28",
   "description": "测试项目，请勿使用。",
   "type": "module",
   "bin": {

package/src/auto.js

@@ -22,19 +22,23 @@ export const MODEL_STATUS = Object.freeze({
 
 // Legacy modelErrors entries are bare timestamps ({id: ts}); newer ones are
 // objects ({id: {status, at, code}}). Normalize both to an entry object.
+// `slow` flags a model whose last request was slow (over the wall-clock
+// threshold) — those get a longer cooldown so they lie low until they recover.
 function normEntry(e) {
-  if (typeof e === "number") return { status: MODEL_STATUS.ERROR, at: e, code: null };
+  if (typeof e === "number") return { status: MODEL_STATUS.ERROR, at: e, code: null, slow: false };
   if (e && typeof e === "object") {
     return {
       status: e.status || MODEL_STATUS.ERROR,
       at: typeof e.at === "number" ? e.at : 0,
       code: e.code ?? null,
+      slow: Boolean(e.slow),
     };
   }
   return null;
 }
 
 export function classifyErrorEvent(evt = {}) {
+  if (evt.slow) return MODEL_STATUS.ERROR;
   const code = Number(evt.status);
   if (code === 429) return MODEL_STATUS.LIMIT;
   const msg = String(evt.message || evt.note || "").toLowerCase();
@@ -45,21 +49,29 @@ export function classifyErrorEvent(evt = {}) {
 }
 
 export const DEFAULT_COOLDOWN_MS = 60_000;
+export const DEFAULT_SLOW_COOLDOWN_MS = 5 * 60_000;
 
-function inCooldown(id, errors, now, cooldownMs) {
-  if (!cooldownMs) return false;
-  const at = normEntry(errors[id])?.at ?? 0;
-  return at > 0 && now - at < cooldownMs;
+function effectiveCooldown(entry, slowCooldownMs, cooldownMs) {
+  if (entry && entry.slow) return slowCooldownMs || 0;
+  return cooldownMs || 0;
 }
 
-export function rankModels(ids, errors = {}, { now = Date.now(), cooldownMs = 0 } = {}) {
+function inCooldown(id, errors, now, cooldownMs, slowCooldownMs) {
+  const e = normEntry(errors[id]);
+  if (!e || !(e.at > 0)) return false;
+  const cd = effectiveCooldown(e, slowCooldownMs, cooldownMs);
+  return cd > 0 && now - e.at < cd;
+}
+
+export function rankModels(ids, errors = {}, { now = Date.now(), cooldownMs = 0, slowCooldownMs = 0 } = {}) {
   return [...new Set(ids)]
     .filter(Boolean)
     .map((id) => ({
       id,
+      e: normEntry(errors[id]),
       err: normEntry(errors[id])?.at ?? 0,
       isDeepseek: /deepseek/i.test(id),
-      cooling: inCooldown(id, errors, now, cooldownMs),
+      cooling: inCooldown(id, errors, now, cooldownMs, slowCooldownMs),
     }))
     .sort(
       (a, b) =>
@@ -75,6 +87,7 @@ export function createAutoSelector({
   file,
   now = () => Date.now(),
   cooldownMs = DEFAULT_COOLDOWN_MS,
+  slowCooldownMs = DEFAULT_SLOW_COOLDOWN_MS,
   errors: seedErrors,
   persist = (errors, f = file) => saveModelErrors(errors, f ? { file: f } : {}),
 } = {}) {
@@ -92,7 +105,7 @@ export function createAutoSelector({
   }
 
   async function candidates() {
-    return rankModels(await loadList(), lastErrorAt, { now: now(), cooldownMs });
+    return rankModels(await loadList(), lastErrorAt, { now: now(), cooldownMs, slowCooldownMs });
   }
 
   async function candidatesFor(requested) {
@@ -102,15 +115,16 @@ export function createAutoSelector({
     const others = rankModels(all.filter((id) => id !== requested), lastErrorAt, {
       now: now(),
       cooldownMs,
+      slowCooldownMs,
     });
-    if (inCooldown(requested, lastErrorAt, now(), cooldownMs)) {
+    if (inCooldown(requested, lastErrorAt, now(), cooldownMs, slowCooldownMs)) {
       return [...others, requested];
     }
     return [requested, ...others];
   }
 
   function isCooling(id) {
-    return inCooldown(id, lastErrorAt, now(), cooldownMs);
+    return inCooldown(id, lastErrorAt, now(), cooldownMs, slowCooldownMs);
   }
 
   async function recordError(id, evt = {}) {
@@ -119,13 +133,14 @@ export function createAutoSelector({
       status: classifyErrorEvent(evt),
       at: now(),
       code: Number.isInteger(Number(evt.status)) ? Number(evt.status) : null,
+      slow: Boolean(evt.slow),
     };
     await persist({ ...lastErrorAt });
   }
 
   async function recordOk(id) {
     if (!id) return;
-    lastErrorAt[id] = { status: MODEL_STATUS.NORMAL, at: now(), code: 200 };
+    lastErrorAt[id] = { status: MODEL_STATUS.NORMAL, at: now(), code: 200, slow: false };
     await persist({ ...lastErrorAt });
   }
 

package/src/routes.js

@@ -244,7 +244,7 @@ export const PEER_RACE_LIMIT = Number(process.env.MSLXDFF_PEER_RACE_LIMIT) > 0
 // Set MSLXDFF_SLOW_TOTAL_MS=0 to disable.
 export const SLOW_TOTAL_MS = (() => {
   const n = Number(process.env.MSLXDFF_SLOW_TOTAL_MS);
-  return Number.isInteger(n) && n > 0 ? n : 15_000;
+  return Number.isInteger(n) && n > 0 ? n : 20_000;
 })();
 
 // How long to wait for the first chunk of a streamed response before giving up