zevairouter 1.0.35 → 1.0.37

package/cli/app/src/lib/oauth/services/socksHttpBridge.js

@@ -0,0 +1,157 @@
+/**
+ * Local SOCKS5-to-HTTP proxy bridge for Playwright/Chromium.
+ *
+ * Chromium cannot authenticate SOCKS5 natively. This module spins up a local
+ * unauthenticated HTTP proxy that forwards CONNECT tunnels through an
+ * authenticated SOCKS5 upstream via the `socks` package.
+ *
+ * Usage:
+ *   const handle = await ensureSocksHttpBridge("socks5://user:pass@host:port");
+ *   // use handle.httpProxyUrl as Playwright proxy server (no auth)
+ *   // ...
+ *   await handle.release();
+ */
+
+import http from "node:http";
+import { SocksClient } from "socks";
+
+const bridges = new Map(); // key -> { server, port, refCount, httpProxyUrl, closePromise }
+
+function parseSocksUrl(proxyUrl) {
+  const url = new URL(String(proxyUrl).trim());
+  const protocol = (url.protocol || "").replace(/:$/, "").toLowerCase();
+  if (!protocol.startsWith("socks")) {
+    return null;
+  }
+  return {
+    host: url.hostname,
+    port: Number(url.port) || (protocol.includes("4") ? 1080 : 1080),
+    type: protocol.includes("4") ? 4 : 5,
+    userId: url.username ? decodeURIComponent(url.username) : undefined,
+    password: url.password ? decodeURIComponent(url.password) : undefined,
+    key: `${protocol}://${url.username}@${url.hostname}:${url.port || 1080}`,
+  };
+}
+
+function socksConnect(socks, host, port) {
+  return SocksClient.createConnection({
+    proxy: {
+      host: socks.host,
+      port: socks.port,
+      type: socks.type,
+      userId: socks.userId,
+      password: socks.password,
+    },
+    command: "connect",
+    destination: { host, port: Number(port) },
+    timeout: 25_000,
+  });
+}
+
+function pipe(a, b) {
+  a.pipe(b);
+  b.pipe(a);
+  const close = () => {
+    a.destroy();
+    b.destroy();
+  };
+  a.on("error", close);
+  b.on("error", close);
+  a.on("close", () => b.destroy());
+  b.on("close", () => a.destroy());
+}
+
+async function startBridge(socks) {
+  const server = http.createServer((req, res) => {
+    // Plain HTTP requests are uncommon for Playwright (uses CONNECT for HTTPS).
+    res.writeHead(405, { "Content-Type": "text/plain" });
+    res.end("CONNECT only");
+  });
+
+  server.on("connect", async (req, clientSocket, head) => {
+    try {
+      const [host, portStr] = String(req.url || "").split(":");
+      const port = Number(portStr) || 443;
+      if (!host) {
+        clientSocket.write("HTTP/1.1 400 Bad Request\r\n\r\n");
+        clientSocket.destroy();
+        return;
+      }
+      const info = await socksConnect(socks, host, port);
+      const remote = info.socket;
+      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      if (head && head.length) remote.write(head);
+      pipe(clientSocket, remote);
+    } catch (error) {
+      try {
+        clientSocket.write("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+      } catch {
+        // ignore
+      }
+      clientSocket.destroy();
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    // port 0 = ephemeral
+    server.listen(0, "127.0.0.1", () => resolve());
+  });
+
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 0;
+  const httpProxyUrl = `http://127.0.0.1:${port}`;
+
+  return {
+    server,
+    port,
+    httpProxyUrl,
+    refCount: 0,
+    async close() {
+      await new Promise((resolve) => server.close(() => resolve()));
+    },
+  };
+}
+
+/**
+ * Ensure a local HTTP proxy bridge for the given SOCKS5 URL.
+ * Returns { httpProxyUrl, release } — call release() when the browser context closes.
+ */
+export async function ensureSocksHttpBridge(proxyUrl) {
+  const socks = parseSocksUrl(proxyUrl);
+  if (!socks) return null;
+
+  // No auth needed for socks without credentials — Playwright can use it directly
+  if (!socks.userId && !socks.password) return null;
+
+  let entry = bridges.get(socks.key);
+  if (!entry) {
+    entry = await startBridge(socks);
+    bridges.set(socks.key, entry);
+  }
+  entry.refCount += 1;
+
+  let released = false;
+  return {
+    httpProxyUrl: entry.httpProxyUrl,
+    async release() {
+      if (released) return;
+      released = true;
+      entry.refCount = Math.max(0, entry.refCount - 1);
+      if (entry.refCount === 0) {
+        bridges.delete(socks.key);
+        await entry.close().catch(() => null);
+      }
+    },
+  };
+}
+
+export function isSocksProxyUrl(proxyUrl) {
+  if (!proxyUrl) return false;
+  try {
+    const protocol = new URL(String(proxyUrl).trim()).protocol.replace(/:$/, "").toLowerCase();
+    return protocol.startsWith("socks");
+  } catch {
+    return /^socks/i.test(String(proxyUrl));
+  }
+}

package/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zevairouter-cli",
-  "version": "1.0.35",
+  "version": "1.0.37",
   "description": "ZevaiRouter CLI - Start and manage ZevaiRouter server",
   "bin": {
     "zevai": "./cli.js"

package/open-sse/config/providerModels.js

@@ -191,11 +191,16 @@ export const PROVIDER_MODELS = {
     { id: "kimi-k2.6", name: "Kimi-K2.6", maxInputTokens: 256000, maxOutputTokens: 32000 },
     { id: "kimi-k2.5", name: "Kimi-K2.5", maxInputTokens: 164000, maxOutputTokens: 32000 },
   ],
-  "cb-cn": [  // CodeBuddy CN - verified available on copilot.tencent.com (2026-06-24)
+  "cb-cn": [  // CodeBuddy CN - verified available on copilot.tencent.com / www.codebuddy.cn
     { id: "default-model-lite", name: "Default-Lite", maxInputTokens: 176000, maxOutputTokens: 24000 },
+    { id: "default-model", name: "Default", maxInputTokens: 176000, maxOutputTokens: 24000 },
     { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro", maxInputTokens: 128000, maxOutputTokens: 8192, strip: ["image", "audio"] },
     { id: "deepseek-v4-flash", name: "DeepSeek V4 Flash", maxInputTokens: 128000, maxOutputTokens: 8192, strip: ["image", "audio"] },
     { id: "glm-5.0", name: "GLM-5.0", maxInputTokens: 200000, maxOutputTokens: 48000, strip: ["image", "audio"] },
+    { id: "glm-5.1", name: "GLM-5.1", maxInputTokens: 200000, maxOutputTokens: 48000, strip: ["image", "audio"] },
+    { id: "kimi-k2.5", name: "Kimi-K2.5", maxInputTokens: 164000, maxOutputTokens: 32000 },
+    { id: "kimi-k2.6", name: "Kimi-K2.6", maxInputTokens: 256000, maxOutputTokens: 32000 },
+    { id: "minimax-m2.5", name: "MiniMax-M2.5", maxInputTokens: 200000, maxOutputTokens: 32000, strip: ["image", "audio"] },
   ],
   cu: [  // Cursor IDE
     { id: "default", name: "Auto (Server Picks)" },
@@ -534,6 +539,29 @@ export const PROVIDER_MODELS = {
     { id: "accounts/fireworks/models/qwen3-235b-a22b", name: "Qwen3 235B" },
     { id: "nomic-ai/nomic-embed-text-v1.5", name: "Nomic Embed Text v1.5", type: "embedding" },
   ],
+  // Wave-1 ports from 9router (keys = provider alias used by getModelsByProviderId)
+  mmf: [
+    { id: "mimo-auto", name: "MiMo Auto" },
+  ],
+  venice: [
+    { id: "venice-uncensored-1-2", name: "Venice Uncensored 1.2" },
+    { id: "zai-org-glm-5", name: "GLM-5" },
+    { id: "qwen3-235b-a22b-instruct-2507", name: "Qwen3 235B A22B Instruct" },
+    { id: "qwen3-coder-480b-a35b-instruct-turbo", name: "Qwen3 Coder 480B A35B Turbo" },
+    { id: "deepseek-v4-pro", name: "DeepSeek V4 Pro" },
+    { id: "llama-3.3-70b", name: "Llama 3.3 70B" },
+    { id: "text-embedding-3-large", name: "Text Embedding 3 Large", type: "embedding" },
+    { id: "text-embedding-bge-m3", name: "BGE-M3 Embedding", type: "embedding" },
+  ],
+  fl: [
+    { id: "deepseek-ai/DeepSeek-V4-Pro", name: "DeepSeek V4 Pro" },
+    { id: "deepseek-ai/DeepSeek-V4-Flash", name: "DeepSeek V4 Flash" },
+    { id: "zai-org/GLM-5.2", name: "GLM 5.2" },
+    { id: "zai-org/GLM-5.1", name: "GLM 5.1" },
+    { id: "moonshotai/Kimi-K2.7-Code", name: "Kimi K2.7 Code" },
+    { id: "moonshotai/Kimi-K2.6", name: "Kimi K2.6" },
+    { id: "moonshotai/Kimi-K2.5", name: "Kimi K2.5" },
+  ],
   cerebras: [
     { id: "gpt-oss-120b", name: "GPT OSS 120B" },
     { id: "zai-glm-4.7", name: "ZAI GLM 4.7" },
@@ -939,6 +967,9 @@ const OAUTH_ALIASES = {
   "codebuddy-cn": "cb-cn",
   vertex: "vertex",
   "vertex-partner": "vertex-partner",
+  "mimo-free": "mmf",
+  venice: "venice",
+  featherless: "fl",
 };
 
 // Derived from PROVIDERS — no need to maintain manually

package/open-sse/config/providers.js

@@ -416,6 +416,20 @@ export const PROVIDERS = {
     baseUrl: "https://token-plan-sgp.xiaomimimo.com/v1/chat/completions",
     format: "openai"
   },
+  // Free Xiaomi MiMo Code (no user key; executor bootstraps JWT)
+  "mimo-free": {
+    baseUrl: "https://api.xiaomimimo.com/api/free-ai/openai/chat",
+    format: "openai",
+    noAuth: true,
+  },
+  venice: {
+    baseUrl: "https://api.venice.ai/api/v1/chat/completions",
+    format: "openai",
+  },
+  featherless: {
+    baseUrl: "https://api.featherless.ai/v1/chat/completions",
+    format: "openai",
+  },
   // Region map for Xiaomi MiMo Token Plan (keys are cluster-specific)
   // Used by resolveXiaomiTokenplanBaseUrl below
   // === Free-tier providers (synced from OmniRoute) ===

package/open-sse/executors/codebuddy-cn.js

@@ -0,0 +1,31 @@
+import { DefaultExecutor } from "./default.js";
+
+/**
+ * CodeBuddy CN — OpenAI-compatible gateway at codebuddy.cn / copilot.tencent.com.
+ *
+ * Forces streaming (upstream rejects non-stream chat with 11101) and only
+ * attaches reasoning_summary when the client asked for reasoning_effort
+ * (forcing reasoning on plain requests trips content filters).
+ *
+ * Ported from 9router executors/codebuddy-cn.js.
+ */
+export class CodeBuddyCnExecutor extends DefaultExecutor {
+  constructor() {
+    super("codebuddy-cn");
+  }
+
+  transformRequest(model, body, stream, credentials) {
+    const transformed = super.transformRequest(model, body, stream, credentials);
+    transformed.stream = true;
+
+    const eff = transformed.reasoning_effort;
+    if (eff === "none" || eff === "off") {
+      delete transformed.reasoning_effort;
+    } else if (eff) {
+      transformed.reasoning_summary = "auto";
+    }
+    return transformed;
+  }
+}
+
+export default CodeBuddyCnExecutor;

package/open-sse/executors/index.js

@@ -17,6 +17,8 @@ import { OllamaLocalExecutor } from "./ollama-local.js";
 import { CommandCodeExecutor } from "./commandcode.js";
 import { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
 import { AutoClawExecutor } from "./autoclaw.js";
+import { MimoFreeExecutor } from "./mimo-free.js";
+import { CodeBuddyCnExecutor } from "./codebuddy-cn.js";
 import { DefaultExecutor } from "./default.js";
 
 const executors = {
@@ -41,6 +43,9 @@ const executors = {
   commandcode: new CommandCodeExecutor(),
   "xiaomi-tokenplan": new XiaomiTokenplanExecutor(),
   autoclaw: new AutoClawExecutor(),
+  "mimo-free": new MimoFreeExecutor(),
+  mmf: new MimoFreeExecutor(),
+  "codebuddy-cn": new CodeBuddyCnExecutor(),
 };
 
 const defaultCache = new Map();
@@ -76,3 +81,5 @@ export { OllamaLocalExecutor } from "./ollama-local.js";
 export { CommandCodeExecutor } from "./commandcode.js";
 export { XiaomiTokenplanExecutor } from "./xiaomi-tokenplan.js";
 export { AutoClawExecutor } from "./autoclaw.js";
+export { MimoFreeExecutor } from "./mimo-free.js";
+export { CodeBuddyCnExecutor } from "./codebuddy-cn.js";

package/open-sse/executors/mimo-free.js

@@ -0,0 +1,156 @@
+import { BaseExecutor } from "./base.js";
+import { PROVIDERS } from "../config/providers.js";
+import { proxyAwareFetch } from "../utils/proxyFetch.js";
+import { createHash } from "crypto";
+import os from "os";
+
+const BOOTSTRAP_URL = "https://api.xiaomimimo.com/api/free-ai/bootstrap";
+const CHAT_URL = PROVIDERS["mimo-free"]?.baseUrl || "https://api.xiaomimimo.com/api/free-ai/openai/chat";
+const SESSION_AFFINITY_PREFIX = "ses_";
+const SESSION_ID_LENGTH = 24;
+const JWT_FALLBACK_TTL_SEC = 3000;
+const JWT_EXPIRY_BUFFER_MS = 300000;
+const SESSION_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
+
+// Anti-abuse gate: upstream rejects requests without a Chrome-like User-Agent with 403 "Illegal access"
+const USER_AGENTS = [
+  "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+  "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
+];
+
+// Anti-abuse gate marker: free chat endpoint returns 403 unless a system message contains this.
+export const MIMO_SYSTEM_MARKER =
+  "You are MiMoCode, an interactive CLI tool that helps users with software engineering tasks.";
+
+let cachedJwt = null;
+let jwtExpiresAt = 0;
+
+function generateFingerprint() {
+  let username = "unknown-user";
+  try {
+    username = os.userInfo().username;
+  } catch {
+    // ignore
+  }
+  const cpu = (os.cpus()[0]?.model || "unknown-cpu").trim();
+  const seed = `${os.hostname()}|${os.platform()}|${os.arch()}|${cpu}|${username}`;
+  return createHash("sha256").update(seed).digest("hex");
+}
+
+function generateSessionId() {
+  let id = SESSION_AFFINITY_PREFIX;
+  for (let i = 0; i < SESSION_ID_LENGTH; i++) {
+    id += SESSION_CHARS[Math.floor(Math.random() * SESSION_CHARS.length)];
+  }
+  return id;
+}
+
+function parseJwtExp(jwt) {
+  try {
+    const payload = JSON.parse(Buffer.from(jwt.split(".")[1], "base64").toString());
+    if (payload.exp) return payload.exp * 1000;
+  } catch {
+    // ignore
+  }
+  return Date.now() + JWT_FALLBACK_TTL_SEC * 1000;
+}
+
+function injectSystemMarker(body) {
+  const messages = body?.messages;
+  if (!Array.isArray(messages)) return body;
+  const hasMarker = messages.some(
+    (m) => m?.role === "system" && typeof m.content === "string" && m.content.includes(MIMO_SYSTEM_MARKER),
+  );
+  if (hasMarker) return body;
+  return { ...body, messages: [{ role: "system", content: MIMO_SYSTEM_MARKER }, ...messages] };
+}
+
+function resetJwtCache() {
+  cachedJwt = null;
+  jwtExpiresAt = 0;
+}
+
+async function bootstrapJwt(proxyOptions = null) {
+  if (cachedJwt && Date.now() < jwtExpiresAt - JWT_EXPIRY_BUFFER_MS) {
+    return cachedJwt;
+  }
+
+  const response = await proxyAwareFetch(BOOTSTRAP_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
+    },
+    body: JSON.stringify({ client: generateFingerprint() }),
+  }, proxyOptions);
+
+  if (!response.ok) {
+    throw new Error(`MiMo bootstrap failed: ${response.status}`);
+  }
+
+  const data = await response.json();
+  if (!data.jwt) {
+    throw new Error("MiMo bootstrap returned no JWT");
+  }
+
+  cachedJwt = data.jwt;
+  jwtExpiresAt = parseJwtExp(data.jwt);
+  return cachedJwt;
+}
+
+export class MimoFreeExecutor extends BaseExecutor {
+  constructor() {
+    super("mimo-free", PROVIDERS["mimo-free"]);
+    this.sessionId = generateSessionId();
+  }
+
+  buildUrl() {
+    return CHAT_URL;
+  }
+
+  buildHeaders(credentials, stream = true) {
+    return {
+      "Content-Type": "application/json",
+      "X-Mimo-Source": "mimocode-cli-free",
+      "User-Agent": USER_AGENTS[Math.floor(Math.random() * USER_AGENTS.length)],
+      "x-session-affinity": this.sessionId,
+      Accept: stream ? "text/event-stream" : "application/json",
+    };
+  }
+
+  transformRequest(model, body) {
+    return injectSystemMarker(body);
+  }
+
+  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
+    let jwt;
+    try {
+      jwt = await bootstrapJwt(proxyOptions);
+    } catch (error) {
+      log?.error?.("AUTH", `MiMo bootstrap failed: ${error.message}`);
+      throw error;
+    }
+
+    const url = this.buildUrl();
+    const transformedBody = this.transformRequest(model, body);
+    const headers = { ...this.buildHeaders(credentials, stream), Authorization: `Bearer ${jwt}` };
+    const bodyStr = JSON.stringify(transformedBody);
+    log?.debug?.("FETCH", `MIMO-FREE → ${url} | body=${bodyStr.length}B`);
+
+    const response = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
+
+    if (response.status === 401 || response.status === 403) {
+      log?.debug?.("AUTH", `MiMo auth failed (${response.status}), re-bootstrapping...`);
+      resetJwtCache();
+      jwt = await bootstrapJwt(proxyOptions);
+      headers.Authorization = `Bearer ${jwt}`;
+      const retryResponse = await proxyAwareFetch(url, { method: "POST", headers, body: bodyStr, signal }, proxyOptions);
+      return { response: retryResponse, url, headers, transformedBody };
+    }
+
+    return { response, url, headers, transformedBody };
+  }
+}
+
+export default MimoFreeExecutor;

package/open-sse/handlers/chatCore.js

@@ -22,6 +22,7 @@ import { injectCaveman } from "../rtk/caveman.js";
 import { injectPonytail } from "../rtk/ponytail.js";
 import { injectContextFiles } from "../context/injectContext.js";
 import { compressMessages, formatRtkLog } from "../rtk/index.js";
+import { applyThinkingFromModelAndSettings, stripThinkingSuffix } from "../utils/thinkingSuffix.js";
 
 /**
  * Core chat handler - shared between SSE and Worker
@@ -31,38 +32,28 @@ import { compressMessages, formatRtkLog } from "../rtk/index.js";
  * @param {string} options.sourceFormatOverride - Override detected source format (e.g. "openai-responses")
  */
 export async function handleChatCore({ body, modelInfo, credentials, log, onCredentialsRefreshed, onRequestSuccess, onDisconnect, clientRawRequest, connectionId, userAgent, apiKey, ccFilterNaming, rtkEnabled, cavemanEnabled, cavemanLevel, contextInjectionEnabled, ponytailEnabled, ponytailLevel, sourceFormatOverride, providerThinking }) {
-  const { provider, model } = modelInfo;
+  const { provider } = modelInfo;
   const requestStartTime = Date.now();
 
   const sourceFormat = sourceFormatOverride || detectFormat(body);
 
   // Check for bypass patterns (warmup, skip, cc naming)
-  const bypassResponse = handleBypassRequest(body, model, userAgent, ccFilterNaming);
+  const bypassResponse = handleBypassRequest(body, modelInfo.model, userAgent, ccFilterNaming);
   if (bypassResponse) return bypassResponse;
 
+  // model(high) suffix + per-provider thinking settings → reasoning_effort / thinking
+  const thinkingApplied = applyThinkingFromModelAndSettings(modelInfo.model, body, providerThinking);
+  body = thinkingApplied.body;
+  const model = thinkingApplied.cleanModel;
+  if (thinkingApplied.applied) {
+    log?.debug?.("THINKING", `Applied thinking mode=${thinkingApplied.applied} (model=${modelInfo.model})`);
+  }
+
   const alias = PROVIDER_ID_TO_ALIAS[provider] || provider;
   const modelTargetFormat = getModelTargetFormat(alias, model);
   const targetFormat = modelTargetFormat || getTargetFormat(provider);
   const stripList = getModelStrip(alias, model);
-  const upstreamModel = getModelUpstreamId(alias, model);
-
-  // Inject provider-level thinking config override (only if client hasn't set)
-  // on/off → extended type (body.thinking), none/low/medium/high → effort type (body.reasoning_effort)
-  if (providerThinking?.mode && providerThinking.mode !== "auto") {
-    const mode = providerThinking.mode;
-    if (mode === "on" && !body.thinking) {
-      console.log("Injecting provider-level thinking config override: on");
-      body = { ...body, thinking: { type: "enabled", budget_tokens: 10000 } };
-    } else if (mode === "off") {
-      body = { ...body, thinking: { type: "disabled" } };
-      delete body.reasoning_effort;
-      if (body.reasoning && typeof body.reasoning === "object") {
-        body.reasoning = { ...body.reasoning, effort: "none" };
-      }
-    } else if (!body.reasoning_effort) {
-      body = { ...body, reasoning_effort: mode };
-    }
-  }
+  const upstreamModel = stripThinkingSuffix(getModelUpstreamId(alias, model));
 
   const clientRequestedStreaming = body.stream === true || sourceFormat === FORMATS.ANTIGRAVITY || sourceFormat === FORMATS.GEMINI || sourceFormat === FORMATS.GEMINI_CLI;
   const providerRequiresStreaming = provider === "openai" || provider === "codex" || provider === "commandcode";

package/open-sse/services/model.js

@@ -81,6 +81,11 @@ const ALIAS_TO_PROVIDER_ID = {
   "xiaomi-mimo": "xiaomi-mimo",
   xmtp: "xiaomi-tokenplan",
   "xiaomi-tokenplan": "xiaomi-tokenplan",
+  mmf: "mimo-free",
+  "mimo-free": "mimo-free",
+  venice: "venice",
+  fl: "featherless",
+  featherless: "featherless",
   cf: "cloudflare-ai",
   "cloudflare-ai": "cloudflare-ai",
   // Image/video providers

package/open-sse/services/usage.js

@@ -343,21 +343,33 @@ function parseCodeBuddyUsage(payload) {
     };
   }
 
+  // Split refill packs (monthly cycle resets) vs one-shot bonus packs so the UI
+  // does not imply bonus credits replenish every month (ported from 9router).
+  const REFILL_GAP_MS = 2 * 24 * 60 * 60 * 1000;
+  const cycleEndMs = (acc) => {
+    const r = parseResetTime(acc.CycleEndTime);
+    return r ? new Date(r).getTime() : Number.POSITIVE_INFINITY;
+  };
+  const isRefill = (acc) => {
+    const ce = cycleEndMs(acc);
+    const de = Number(acc.DeductionEndTime);
+    return Number.isFinite(ce) && Number.isFinite(de) && de - ce > REFILL_GAP_MS;
+  };
+  const byExpiry = (a, b) => cycleEndMs(a) - cycleEndMs(b);
+
+  const refills = accounts.filter(isRefill).sort(byExpiry);
+  const bonuses = accounts.filter((a) => !isRefill(a)).sort(byExpiry);
+
   const quotas = {};
   let hasProPackage = false;
 
-  for (const account of accounts) {
-    if (!account || typeof account !== "object") continue;
-    const label = getCodeBuddyQuotaLabel(account.PackageCode);
-    if (!label) continue;
-
-    if (account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proMon || account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proYear) {
+  const addQuota = (label, account, { recurring }) => {
+    const quota = getCodeBuddyQuotaValues(account, { useCycle: recurring });
+    if (!quota) return;
+    if (account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proMon
+      || account.PackageCode === CODEBUDDY_CONFIG.packageCodes.proYear) {
       hasProPackage = true;
     }
-
-    const quota = getCodeBuddyQuotaValues(account);
-    if (!quota) continue;
-
     if (!quotas[label]) {
       quotas[label] = {
         used: 0,
@@ -366,13 +378,37 @@ function parseCodeBuddyUsage(payload) {
         resetAt: null,
         unit: "credits",
         unlimited: false,
+        recurring,
       };
     }
-
     quotas[label].used += quota.used;
     quotas[label].total += quota.total;
     quotas[label].remaining += quota.remaining;
     quotas[label].resetAt = getEarlierReset(quotas[label].resetAt, quota.resetAt);
+    quotas[label].recurring = quotas[label].recurring && recurring;
+  };
+
+  // Aggregate ALL refill packs into one Monthly row and ALL bonus packs into one
+  // Bonus row — Tencent often returns many small gift packages (10–20 rows) for a
+  // single account, which flooded the dashboard as Bonus Pack 1..N.
+  for (const account of refills) {
+    addQuota("Monthly Credits", account, { recurring: true });
+  }
+  for (const account of bonuses) {
+    addQuota("Bonus Credits", account, { recurring: false });
+  }
+  if (bonuses.length > 0 && quotas["Bonus Credits"]) {
+    quotas["Bonus Credits"].packCount = bonuses.length;
+  }
+
+  // Fallback: if classification produced nothing, keep old package-label merge.
+  if (Object.keys(quotas).length === 0) {
+    for (const account of accounts) {
+      if (!account || typeof account !== "object") continue;
+      const label = getCodeBuddyQuotaLabel(account.PackageCode) || "Other Credits";
+      const recurring = label !== "Activity Credits" && label !== "Gift Credits";
+      addQuota(recurring ? "Monthly Credits" : "Bonus Credits", account, { recurring });
+    }
   }
 
   if (Object.keys(quotas).length === 0) {
@@ -389,8 +425,10 @@ function parseCodeBuddyUsage(payload) {
       : 0;
   }
 
+  const plan = hasProPackage ? "Pro" : "Free";
   return {
-    plan: hasProPackage ? "Pro" : "Free",
+    plan,
+    // packCount stays on Bonus Credits for UI/detail if needed; no noisy top-level message
     quotas,
   };
 }
@@ -414,18 +452,32 @@ function getCodeBuddyQuotaLabel(packageCode) {
   }
 }
 
-function getCodeBuddyQuotaValues(account) {
-  const total = firstFiniteNumber(
-    account.CycleCapacitySizePrecise,
-    account.CycleCapacitySize,
-    account.CapacitySizePrecise,
-    account.CapacitySize,
-  );
-  const remaining = firstFiniteNumber(
-    account.CycleCapacityRemainPrecise,
-    account.CapacityRemainPrecise,
-    account.CapacityRemain,
-  );
+function getCodeBuddyQuotaValues(account, { useCycle = true } = {}) {
+  // Refill packs: Cycle* fields = current period. Bonus packs: plain Capacity* = lifetime one-shot.
+  const total = useCycle
+    ? firstFiniteNumber(
+      account.CycleCapacitySizePrecise,
+      account.CycleCapacitySize,
+      account.CapacitySizePrecise,
+      account.CapacitySize,
+    )
+    : firstFiniteNumber(
+      account.CapacitySizePrecise,
+      account.CapacitySize,
+      account.CycleCapacitySizePrecise,
+      account.CycleCapacitySize,
+    );
+  const remaining = useCycle
+    ? firstFiniteNumber(
+      account.CycleCapacityRemainPrecise,
+      account.CapacityRemainPrecise,
+      account.CapacityRemain,
+    )
+    : firstFiniteNumber(
+      account.CapacityRemainPrecise,
+      account.CapacityRemain,
+      account.CycleCapacityRemainPrecise,
+    );
   const used = firstFiniteNumber(
     account.CapacityUsedPrecise,
     account.CapacityUsed,