mslxdff 0.1.149 → 0.1.150

package/package.json

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

package/src/cli/format.js

@@ -109,6 +109,21 @@ export function fmtEvent(e) {
     case "auto-update-query-failed":
     case "auto-update-install-failed":
       return `${head} auto-update   failed ${e.type} error=${e.error||""}`;
+    case "cline-account-state": {
+      // 限流是「账号 × 模型」维度：模型名打头，pool 表示该模型上的可用账号，
+      // 避免把"这个模型的免费额度用尽"误读成"整池账号报废"。
+      const p = e.pool ? ` acct-ready=${e.pool.ready}/${e.pool.total}` : "";
+      const lm = e.limitedModel ? ` upstream=${e.limitedModel}` : "";
+      const detail = [e.reason, e.status ? `HTTP ${e.status}` : "", e.cooldownMs ? `cool ${Math.round(e.cooldownMs / 1000)}s` : ""].filter(Boolean).join(" ");
+      const hint = e.state === "pool-exhausted" ? " [该模型所有账号额度耗尽 → 换模型或等冷却]" : e.state === "switch" ? " [换号重试]" : e.state === "force-retry" ? " [全部号冷却中，强行取号重试]" : "";
+      return `${head} cline acct    ${e.state} model=${m(e.model)}${lm} account=${m(e.accountId)}${e.from ? ` from=${e.from}` : ""}${detail ? ` ${detail}` : ""}${p}${hint}`;
+    }
+    case "cline-model-usage":
+      return `${head} cline tokens  ${e.state === "limit" ? "限流封存" : "正常输出"}${e.estimated ? "(估算)" : ""} model=${m(e.model)} account=${m(e.accountId)} output=${m(e.outputTokens)} 周期累计=${m(e.cycleOutputTokens)}${e.cycleCount ? ` 第${e.cycleCount}周期` : ""}${e.reason ? ` reason=${e.reason}` : ""}`;
+    case "provider-state":
+      return `${head} provider      ${m(e.provider)} ${m(e.state)}${e.keys !== undefined ? ` keys=${e.keys}` : ""}${e.accounts !== undefined ? ` accounts=${e.accounts}` : ""}${e.baseUrl ? ` baseUrl=${e.baseUrl}` : ""}${e.error ? ` error=${e.error}` : ""}`;
+    case "provider-model-state":
+      return `${head} prov model    ${m(e.provider)} ${m(e.state)} model=${m(e.model)}${e.status ? ` HTTP ${e.status}` : ""}${e.error ? ` error=${e.error}` : ""}${e.durationMs !== undefined ? ` ${fmtDur(e.durationMs)}` : ""}`;
     default:
       return `${head} ${e?.type || "?"} ${JSON.stringify(e || {})}`;
   }

package/src/providers/cline/auth.js

@@ -1,11 +1,20 @@
 import { joinUrl, sleep } from "../base.js";
 import { compatFetch } from "../../compat.js";
+import { appendEvent } from "../../logs.js";
+import { createHash } from "node:crypto";
 
 /**
  * Cline Token 池：多账号 round-robin + refresh 换 accessToken + 冷却 + 队列
  * 对标 pingmike2/cline2api-workers 的 accounts / getAccountToken / parseCooldown / enqueue
  */
 
+
+// 只记哈希标识，不落邮箱 / refreshToken（events.log 可读不可泄）
+function acctId(account) {
+  const seed = String(account?.refreshToken || "");
+  if (!seed) return "slot-unknown";
+  return `acct_${createHash("sha256").update(seed).digest("hex").slice(0, 8)}`;
+}
 export function parseCooldown(body, status) {
   const m = String(body || "").match(/try again in (?:(\d+)\s*h)?\s*(?:(\d+)\s*m)?\s*(?:(\d+)\s*s)?/i);
   if (m) {
@@ -86,7 +95,7 @@ export function createAuthPool({
     }
     const changed = accounts.length !== list.length || accounts.some((a, i) => a.refreshToken !== list[i]);
     if (changed) {
-      accounts = list.map((rt) => ({ refreshToken: rt, accessToken: null, expiry: 0, cooldownUntil: 0 }));
+      accounts = list.map((rt) => ({ refreshToken: rt, accessToken: null, expiry: 0, cooldownUntil: 0, limits: {} }));
       accountIndex = 0;
     }
     return accounts;
@@ -100,14 +109,27 @@ export function createAuthPool({
     queueTail = run.catch(() => {});
     return run;
   }
+  // 模型级限流：Cline 免费额度按「账号 × 模型」计，429 只应挡该模型，
+  // 不得把整个号冻住（muse-spark 被限时 deepseek 仍须能用同一账号）。
+  function markLimit(account, model, cooldownMs) {
+    if (!account || !model) return;
+    if (!account.limits) account.limits = {};
+    account.limits[model] = clock() + cooldownMs;
+  }
+  // 账号可用性：dead（账号死）/ cooldownUntil（refresh 失败，账号级）/ limits[model]（该模型 429）三关
+  function accountAvailable(acc, model, now = clock()) {
+    if (!acc || acc.dead) return false;
+    if (acc.cooldownUntil && acc.cooldownUntil > now) return false;
+    if (model && acc.limits && acc.limits[model] && acc.limits[model] > now) return false;
+    return true;
+  }
 
-  function pickAccount(pool) {
+  function pickAccount(pool, model) {
     const list = pool || accounts;
     for (let k = 0; k < list.length; k++) {
       const acc = list[accountIndex % list.length];
       accountIndex = (accountIndex + 1) % list.length;
-      if (acc.dead) continue;
-      if (!acc.cooldownUntil || acc.cooldownUntil <= clock()) {
+      if (accountAvailable(acc, model)) {
         currentAccount = acc;
         return acc;
       }
@@ -135,8 +157,14 @@ export function createAuthPool({
     if (!res.ok) {
       let t = "";
       try { t = await res.text(); } catch {}
-      if (isInvalidGrant(t, res.status)) { account.dead = true; throw new Error("invalid_grant"); }
-      account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_failed");
+      if (isInvalidGrant(t, res.status)) {
+        account.dead = true;
+        appendEvent({ type: "cline-account-state", provider: id, state: "dead", accountId: acctId(account), status: res.status, reason: "invalid_grant" });
+        throw new Error("invalid_grant");
+      }
+      account.cooldownUntil = now + 60 * 1000;
+      appendEvent({ type: "cline-account-state", provider: id, state: "refresh-failed", accountId: acctId(account), status: res.status, cooldownMs: 60_000 });
+      throw new Error("refresh_failed");
     }
     let data;
     try { data = await res.json(); } catch { account.cooldownUntil = now + 60 * 1000; throw new Error("refresh_no_token"); }
@@ -159,20 +187,36 @@ export function createAuthPool({
     return accessToken;
   }
 
-  async function getAccessToken() {
+  async function getAccessToken(model) {
     const pool = accounts;
     if (pool.length === 0) throw new Error("缺少 CLINE_REFRESH_TOKEN（请用 cline_oauth.py 获取）");
     for (let attempt = 0; attempt < pool.length; attempt++) {
       const acc = pool[attempt % pool.length];
-      if (acc.dead) continue;
-      if (acc.cooldownUntil && acc.cooldownUntil > clock()) continue;
+      if (!accountAvailable(acc, model)) continue;
       currentAccount = acc;
       try { return await refreshOne(acc); } catch (e) { if (e.message === "account_cooldown") continue; continue; }
     }
     const acc = pool.find((a) => !a.dead) || null;
     if (!acc) throw new Error("无可用 Cline 账号");
     currentAccount = acc;
-    acc.cooldownUntil = 0;
+    // 防锁死：该模型全部号被限时，清掉这一号的该模型限制强取重试（只清模型维度，
+    // 不动账号级 cooldownUntil——那是 refresh 失败的冷却，仍由 accountAvailable 把关）。
+    if (model && acc.limits) delete acc.limits[model];
+    if (acc.cooldownUntil && acc.cooldownUntil > clock()) acc.cooldownUntil = 0;
+    appendEvent({
+      type: "cline-account-state",
+      provider: id,
+      state: "force-retry",
+      accountId: acctId(acc),
+      model,
+      reason: "all-accounts-cooling",
+      pool: {
+        total: pool.length,
+        cooling: pool.filter((a) => !accountAvailable(a, model)).length,
+        dead: pool.filter((a) => a.dead).length,
+        ready: pool.filter((a) => accountAvailable(a, model)).length,
+      },
+    });
     return refreshOne(acc);
   }
 
@@ -180,5 +224,5 @@ export function createAuthPool({
   function getAccounts() { return accounts; }
   function updateKeys(newKeys) { parseAccounts(newKeys); }
 
-  return { parseAccounts, getAccessToken, refreshOne, pickAccount, parseCooldown, enqueue, getCurrentAccount, getAccounts, updateKeys, _accounts: () => accounts };
+  return { parseAccounts, getAccessToken, refreshOne, pickAccount, parseCooldown, enqueue, getCurrentAccount, getAccounts, updateKeys, markLimit, accountAvailable, _accounts: () => accounts };
 }

package/src/providers/cline/chat.js

@@ -1,11 +1,41 @@
 import { joinUrl, sleep } from "../base.js";
+import { appendEvent } from "../../logs.js";
+import { createHash } from "node:crypto";
 import { clineHeaders } from "./headers.js";
 import { createTransport } from "../../transport/index.js";
 import { normalizeProviderId } from "../model-id.js";
+import { recordLimit, recordOutput, exactOutputTokens } from "./usage.js";
 import { createSdkDispatch } from "../../upstream-engine/sdk/dispatch.js";
 
 function genSessionId() { return `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`; }
 
+// 只记哈希标识，不落邮箱 / refreshToken（events.log 可读不可泄）
+function acctId(account) {
+  const seed = String(account?.refreshToken || "");
+  if (!seed) return "slot-unknown";
+  return `acct_${createHash("sha256").update(seed).digest("hex").slice(0, 8)}`;
+}
+// 池子快照：ready/cooling 按「该模型」口径统计（ready=对该模型可用的号数）。
+// isReady 由调用方注入 authPool.accountAvailable(a, model)，避免与 auth 逻辑分叉。
+function poolStat(pool, isReady = () => true) {
+  let cooling = 0;
+  let dead = 0;
+  for (const a of pool || []) {
+    if (a.dead) dead++;
+    else if (!isReady(a)) cooling++;
+  }
+  const total = (pool || []).length;
+  return { total, cooling, dead, ready: total - cooling - dead };
+}
+
+// 429 错误体自带权威模型名（"...Daily free limit reached on model meta/muse-spark-1.3-contributor"）。
+function limitModelOf(bodyText) {
+  // 模型名可含 / . - _ : 字母数字（如 meta/muse-spark-1.3-contributor），
+  // 遇空格/引号/逗号/句号结尾或 "Try again" 前的空白即停。
+  const m = String(bodyText || "").match(/on model\s+([A-Za-z0-9/._:-]+?)(?=[\s"',]|\.\s|$)/i);
+  return m ? m[1] : "";
+}
+
 // stripProviderPrefix 只剥「本供应商」前缀（cline/<裸 id> → 裸 id），非本前缀（含上游自带多段 id
 // 如 meta/vendor/x）原样透传，不误削首段（旧实现按段数剥曾是潜在 bug）。
 function stripProviderPrefix(model, providerId) {
@@ -23,7 +53,7 @@ function unwrapData(obj) {
   return obj;
 }
 
-async function streamToNonStream(upstream) {
+async function streamToNonStream(upstream, track = null) {
   let content = "";
   let reasoning = "";
   let finishReason = null;
@@ -49,6 +79,11 @@ async function streamToNonStream(upstream) {
   const msg = { role: "assistant", content };
   if (reasoning) msg.reasoning = reasoning;
   if (!content && reasoning) { msg.content = reasoning; msg.reasoning_used_as_content = true; }
+  if (track) {
+    const exact = exactOutputTokens(usage);
+    if (exact) track({ tokens: exact, estimated: false });
+    else if (content || reasoning) track({ tokens: Math.ceil((content.length + reasoning.length) / 4), estimated: true });
+  }
   return {
     id: id || `gen_${Date.now()}`,
     object: "chat.completion",
@@ -74,7 +109,8 @@ export function createChatService({
   const sdk = createSdkDispatch({ id, providerName: id || "cline" });
 
   async function clineFetch(body, sessionId, allowSdk = false) {
-    const token = await authPool.getAccessToken();
+    const token = await authPool.getAccessToken(body?.model);
+    appendEvent({ type: "cline-account-state", provider: id || "cline", state: "selected", accountId: acctId(authPool.getCurrentAccount()), model: body?.model, pool: poolStat(authPool.getAccounts(), (a) => authPool.accountAvailable(a, body?.model)) });
     const headers = clineHeaders(sessionId, token);
     const finalUrl = joinUrl(resolvedBase, resolvedChat);
     const isStream = body?.stream === true;
@@ -85,6 +121,8 @@ export function createChatService({
     }
     return transport.request({ url: finalUrl, headers, body, stream: isStream, timeoutMs: connectTimeoutMs });
   }
+  // 记账回调：捕获当前账号哈希，成功输出进当前额度周期
+  const track = (model) => ({ tokens, estimated }) => recordOutput({ accountId: acctId(authPool.getCurrentAccount()), model, tokens, estimated }).catch(() => {});
 
   function isLimitHit(status, bodyText) {
     if (status === 429) return true;
@@ -113,9 +151,32 @@ export function createChatService({
         const { parseCooldown } = await import("./auth.js");
         const cooldownMs = parseCooldown(bodyText, resp.status);
         const cur = authPool.getCurrentAccount();
-        if (cur) { cur.cooldownUntil = Date.now() + cooldownMs; cur.accessToken = null; cur.expiry = 0; }
+        // 免费额度按「账号 × 模型」计：只把该模型挂到这个号上（limits[model]），
+        // 不动账号级 cooldownUntil、不清 accessToken——同号其它模型照常可用。
+        authPool.markLimit(cur, body?.model, cooldownMs);
+        const limitedModel = limitModelOf(bodyText);
+        if (limitedModel && limitedModel !== body?.model) authPool.markLimit(cur, limitedModel, cooldownMs);
+        const cycle = await recordLimit({ accountId: acctId(cur), model: body?.model, reason: resp.status === 429 ? "daily_limit" : "empty_response", status: resp.status, cooldownMs });
         const pool = authPool.getAccounts();
-        const hasOther = pool.some((a) => !a.cooldownUntil || a.cooldownUntil <= Date.now());
+        const ready = (a) => authPool.accountAvailable(a, body?.model);
+        const hasOther = pool.some(ready);
+        // 限流是「账号 × 模型」维度：429 只说明当前账号在这个模型上额度用尽，
+        // 换模型（如 muse-spark → deepseek）往往仍可用，故日志必须点名模型。
+        appendEvent({
+          type: "cline-account-state",
+          provider: id || "cline",
+          state: hasOther ? "switch" : "pool-exhausted",
+          accountId: acctId(cur),
+          model: body?.model,
+          limitedModel: limitedModel || undefined,
+          scope: "model",
+          reason: resp.status === 429 ? "daily_limit" : "empty_response",
+          status: resp.status,
+          cooldownMs,
+          pool: poolStat(pool, ready),
+          cycleOutputTokens: cycle?.cycleOutputTokens ?? 0,
+          cycleCount: cycle?.cycleCount ?? 0,
+        });
         if (!hasOther) return resp;
         await sleep(500 + Math.floor(Math.random() * 500));
         continue;
@@ -140,7 +201,7 @@ export function createChatService({
       }
       const ct = resp.headers.get("content-type") || "";
       let normalized = null;
-      if (ct.includes("text/event-stream")) normalized = await streamToNonStream(resp);
+      if (ct.includes("text/event-stream")) normalized = await streamToNonStream(resp, track(body?.model));
       else {
         const raw = await resp.json().catch(() => null);
         if (raw) normalized = unwrapData(raw);
@@ -154,7 +215,9 @@ export function createChatService({
       if (content && !isFallback) return { data: normalized };
       if (reasoning || isFallback) {
         const cur = authPool.getCurrentAccount();
-        if (cur) { cur.cooldownUntil = Date.now() + 30 * 1000; cur.accessToken = null; cur.expiry = 0; }
+        // 空响应是「模型 × 通道」形态问题（deepseek 非流式特性），同样只挡该模型。
+        authPool.markLimit(cur, body?.model, 30 * 1000);
+        appendEvent({ type: "cline-account-state", provider: id || "cline", state: "cooldown", accountId: acctId(cur), model: body?.model, reason: "empty_response", cooldownMs: 30000, scope: "model", pool: poolStat(authPool.getAccounts(), (a) => authPool.accountAvailable(a, body?.model)) });
         await sleep(300 + Math.floor(Math.random() * 300));
         resp = null;
         continue;
@@ -213,6 +276,10 @@ export function createChatService({
         }
         const normalized = unwrapData(raw);
         normalized.model = model;
+        // 非流式终点：正文估算记账（上游有 usage 时 streamToNonStream 路径才拿得到精确值；此处 raw 无流）
+        const m2 = normalized?.choices?.[0]?.message || {};
+        const outLen2 = String(m2.content || "").length + String(m2.reasoning || "").length;
+        if (outLen2 > 0) track(model)({ tokens: Math.ceil(outLen2 / 4), estimated: true });
         return new Response(JSON.stringify(normalized), { status: 200, headers: { "Content-Type": "application/json" } });
       } catch (err) {
         if (netAttempt < 2 && String(err?.message || "").toLowerCase().includes("timed out")) { await sleep(300); continue; }

package/src/providers/cline/usage.js

@@ -0,0 +1,170 @@
+// Cline 账号 × 模型额度周期统计。
+// 目标：记录“额度恢复后到下一次限流”之间正常响应累计的 output/completion tokens。
+// 不记录 token、邮箱、prompt、响应正文；账号只使用调用方传入的稳定哈希。
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { logDir } from "../../logs.js";
+import { appendEvent } from "../../logs.js";
+
+const FILE = "cline-usage.jsonl";
+const states = new Map();
+let loaded;
+
+function keyOf(accountId, model) {
+  return `${String(accountId || "unknown")}|${String(model || "unknown")}`;
+}
+
+function newState() {
+  return {
+    currentOutputTokens: 0,
+    cycleStartAt: Date.now(),
+    limitedUntil: 0,
+    completedCycles: 0,
+    lastCycleOutputTokens: 0,
+    lastCycleStartAt: null,
+    lastCycleEndAt: null,
+    lastReason: null,
+  };
+}
+
+async function ensureLoaded() {
+  if (!loaded) {
+    loaded = (async () => {
+      let text = "";
+      try { text = await readFile(join(logDir(), FILE), "utf8"); } catch { return; }
+      for (const line of text.split("\n")) {
+        if (!line) continue;
+        try {
+          const row = JSON.parse(line);
+          const k = keyOf(row.accountId, row.model);
+          const s = states.get(k) || newState();
+          if (row.type === "output") {
+            s.currentOutputTokens = Number(row.cycleOutputTokens) || 0;
+            s.cycleStartAt = Number(row.cycleStartAt) || Number(row.at) || s.cycleStartAt;
+            s.limitedUntil = 0;
+          } else if (row.type === "limit") {
+            s.completedCycles = Math.max(0, (Number(row.cycleCount) || 1) - 1);
+            s.lastCycleOutputTokens = Number(row.cycleOutputTokens) || 0;
+            s.lastCycleStartAt = Number(row.cycleStartAt) || null;
+            s.lastCycleEndAt = Number(row.at) || null;
+            s.lastReason = row.reason || null;
+            s.currentOutputTokens = 0;
+            s.cycleStartAt = 0;
+            s.limitedUntil = Number(row.until) || 0;
+          }
+          states.set(k, s);
+        } catch {}
+      }
+    })();
+  }
+  return loaded;
+}
+
+export function exactOutputTokens(usage) {
+  const n = Number(usage?.completion_tokens ?? usage?.completionTokens ?? usage?.output_tokens ?? usage?.outputTokens);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+// 上游有时不给 usage（本次真实 Cline 响应就是如此）；按输出正文估算并明确标记 estimated。
+function parseOutput(text) {
+  const s = String(text || "");
+  let parsed = null;
+  try { parsed = JSON.parse(s); } catch {}
+  if (parsed) {
+    const exact = exactOutputTokens(parsed?.usage || parsed);
+    if (exact) return { tokens: exact, estimated: false };
+    const output = parsed?.choices?.[0]?.message || parsed?.choices?.[0]?.delta || parsed?.output || parsed;
+    return { tokens: Math.ceil(JSON.stringify(output || "").length / 4), estimated: true };
+  }
+  let usage = null;
+  let output = "";
+  for (const line of s.split("\n")) {
+    const t = line.trim();
+    // transport 的 stream() 已剥掉 "data:" 前缀；SDK/原生流则带前缀。两种都认。
+    const raw = t.startsWith("data:") ? t.slice(5).trim() : t;
+    if (!raw || raw === "[DONE]") continue;
+    try {
+      const j = JSON.parse(raw);
+      if (j?.usage) usage = j.usage;
+      const piece = j?.choices?.[0]?.delta || j?.choices?.[0]?.message;
+      if (piece) output += JSON.stringify(piece);
+    } catch {}
+  }
+  const exact = exactOutputTokens(usage);
+  return exact ? { tokens: exact, estimated: false } : { tokens: Math.ceil(output.length / 4), estimated: true };
+}
+
+async function append(row) {
+  try {
+    await mkdir(logDir(), { recursive: true });
+    await appendFile(join(logDir(), FILE), JSON.stringify(row) + "\n");
+  } catch {}
+}
+
+function event(row) {
+  try { appendEvent({ ...row, type: "cline-model-usage" }); } catch {}
+}
+
+function stateFor(accountId, model, now) {
+  const k = keyOf(accountId, model);
+  const s = states.get(k) || newState();
+  if (s.limitedUntil && now >= s.limitedUntil) {
+    s.limitedUntil = 0;
+    s.currentOutputTokens = 0;
+    s.cycleStartAt = now;
+  }
+  states.set(k, s);
+  return s;
+}
+// 在消费终点直接记账（比包装 Response 可靠：streamToNonStream 已解析出 usage/正文，网关透传已有累积 bytes）。
+export function usageFromData(data) {
+  const exact = exactOutputTokens(data?.usage);
+  if (exact) return { tokens: exact, estimated: false };
+  const msg = data?.choices?.[0]?.message;
+  const text = String(msg?.content || "") + String(msg?.reasoning || "");
+  if (!text) return { tokens: 0, estimated: false };
+  return { tokens: Math.ceil(text.length / 4), estimated: true };
+}
+
+
+export async function recordOutput({ accountId, model, tokens, estimated = false } = {}) {
+  const n = Number(tokens);
+  if (!model || !Number.isFinite(n) || n <= 0) return null;
+  await ensureLoaded();
+  const now = Date.now();
+  const s = stateFor(accountId, model, now);
+  s.currentOutputTokens += n;
+  const row = {
+    type: "output", at: now, accountId: accountId || "unknown", model,
+    outputTokens: n, estimated: !!estimated, cycleOutputTokens: s.currentOutputTokens,
+    cycleStartAt: s.cycleStartAt, cycleCount: s.completedCycles + 1,
+  };
+  await append(row);
+  event(row);
+  return row;
+}
+
+export async function recordLimit({ accountId, model, reason = "daily_limit", status = 429, cooldownMs = 0 } = {}) {
+  if (!model) return null;
+  await ensureLoaded();
+  const now = Date.now();
+  const s = stateFor(accountId, model, now);
+  if (s.limitedUntil && s.limitedUntil > now) return null;
+  const row = {
+    type: "limit", at: now, accountId: accountId || "unknown", model,
+    cycleOutputTokens: s.currentOutputTokens, cycleStartAt: s.cycleStartAt,
+    cycleEndAt: now, until: now + Math.max(0, Number(cooldownMs) || 0),
+    reason, status, cycleCount: s.completedCycles + 1,
+  };
+  s.completedCycles += 1;
+  s.lastCycleOutputTokens = s.currentOutputTokens;
+  s.lastCycleStartAt = s.cycleStartAt;
+  s.lastCycleEndAt = now;
+  s.lastReason = reason;
+  s.currentOutputTokens = 0;
+  s.cycleStartAt = 0;
+  s.limitedUntil = row.until;
+  await append(row);
+  event({ ...row, state: "limit" });
+  return row;
+}

package/src/providers/dispatcher.js

@@ -1,3 +1,4 @@
+import { appendEvent } from "../logs.js";
 import { splitModelId, DEFAULT_PROVIDER, joinModelId } from "./model-id.js";
 import { isModelAllowed as stateIsAllowed, loadProviderAllowedModels as stateLoadAllowed, loadProviderAllowAnyModels as stateLoadAllowAny } from "../state.js";
 
@@ -44,18 +45,36 @@ export function createProviderDispatcher(providers = [], opts = {}) {
     if (!isAllowedFn(provider.id, raw)) {
       const allowed = getAllowedFn(provider.id) || [];
       const msg = `model not allowed for provider "${provider.id}": "${raw}" — allowed: ${allowed.join(", ") || "(none)"} (use: mslxdff -provider ${provider.id} allowlist add <model>)`;
+      appendEvent({ type: "provider-model-state", provider: provider.id, model: body?.model, rawModel: raw, state: "blocked", reason: "allowlist", status: 403 });
       return new Response(JSON.stringify({ error: msg }), { status: 403, headers: { "Content-Type": "application/json", "x-mslxdff-allowlist": "1" } });
     }
     const forwarded = raw === body?.model ? body : { ...body, model: raw };
     // ADR-0008：本请求携带瞬时共享 key（shareKeys 由组员侧按 header 解析后传入）。
     const sharedKeys = opts?.shareKeys?.[provider.id];
-    if (sharedKeys && sharedKeys.length && typeof provider.chatWithKeys === "function") {
-      return provider.chatWithKeys(forwarded, sharedKeys, opts);
-    }
-    if (provider.id === "workbuddy" && workbuddyUid) {
-      return provider.chat(forwarded, { ...opts, workbuddyUid });
+    const startedAt = Date.now();
+    let res;
+    try {
+      if (sharedKeys && sharedKeys.length && typeof provider.chatWithKeys === "function") {
+        res = await provider.chatWithKeys(forwarded, sharedKeys, opts);
+      } else if (provider.id === "workbuddy" && workbuddyUid) {
+        res = await provider.chat(forwarded, { ...opts, workbuddyUid });
+      } else {
+        res = await provider.chat(forwarded, opts);
+      }
+    } catch (err) {
+      appendEvent({ type: "provider-model-state", provider: provider.id, model: body?.model, rawModel: raw, state: "upstream-error", error: String(err?.message || err), durationMs: Date.now() - startedAt });
+      throw err;
     }
-    return provider.chat(forwarded, opts);
+    appendEvent({
+      type: "provider-model-state",
+      provider: provider.id,
+      model: body?.model,
+      rawModel: raw,
+      status: res?.status,
+      state: res?.status === 429 ? "limited" : res?.ok ? "ok" : "upstream-error",
+      durationMs: Date.now() - startedAt,
+    });
+    return res;
   }
 
   // 聚合所有供应商的模型列表；默认供应商（opencode）裸 id，其它带前缀

package/src/runtime/providers-setup.js

@@ -100,6 +100,7 @@ export async function setupProviders() {
           providers.push(provider);
           console.log(`provider enabled: ${gid} (${keys.length} key${keys.length > 1 ? "s" : ""}) baseUrl=${base || provider.baseUrl} [custom]`);
           appendEvent({ ts: Date.now(), type: "provider-enabled", provider: gid, keys: keys.length, baseUrl: base || provider.baseUrl });
+          appendEvent({ type: "provider-state", provider: gid, state: "enabled", keys: keys.length, accounts: auths.length, baseUrl: base || provider.baseUrl });
         } catch (err) {
           console.log(`provider ${gid} failed: ${err?.message || err}`);
           appendEvent({ ts: Date.now(), type: "provider-error", provider: gid, error: String(err?.message || err) });
@@ -126,6 +127,7 @@ export async function setupProviders() {
           providers.push(createWorkbuddyProvider({ apiKeys: wbKeys, auths: wbAuths }));
           console.log(`provider enabled: workbuddy (${wbKeys.length} key${wbKeys.length > 1 ? "s" : ""}) baseUrl=https://copilot.tencent.com (env)`);
           appendEvent({ ts: Date.now(), type: "provider-enabled", provider: "workbuddy", keys: wbKeys.length, baseUrl: "https://copilot.tencent.com" });
+          appendEvent({ type: "provider-state", provider: "workbuddy", state: "enabled", keys: wbKeys.length, accounts: wbAuths.length });
         } catch (err) {
           console.log(`provider workbuddy failed: ${err?.message || err}`);
         }