coding-tool-x 3.6.3 → 3.6.5

package/src/server/services/channel-balance.js

@@ -10,8 +10,12 @@ const MAX_RESPONSE_BYTES = 1024 * 1024;
 const QUOTA_UNIT = 500000;
 const VELOERA_QUOTA_UNIT = 1000000;
 const VALID_SOURCES = new Set(['claude', 'codex', 'gemini', 'opencode']);
+const GATEWAY_PATH_SEGMENTS = new Set(['openai', 'anthropic', 'claude', 'gemini', 'codex']);
+const HUB_PLATFORMS = new Set(['new-api', 'one-api', 'one-hub', 'done-hub', 'veloera', 'anyrouter', 'aihubmix']);
+const UNSUPPORTED_BALANCE_PLATFORMS = new Set(['dashscope', 'modelscope']);
 
 const balanceCache = new Map();
+const balanceStrategyCache = new Map();
 
 function nowIso(now = Date.now()) {
   return new Date(now).toISOString();
@@ -22,6 +26,41 @@ function stripBearer(value) {
   return token.toLowerCase().startsWith('bearer ') ? token.slice(7).trim() : token;
 }
 
+function resolveBalanceToken(channel = {}) {
+  return stripBearer(
+    channel.balanceToken
+    || channel.balanceApiKey
+    || channel.balanceAuthToken
+    || channel.apiKey
+    || channel.token
+    || channel.authToken
+    || ''
+  );
+}
+
+function resolveBalanceUserId(channel = {}) {
+  const raw = channel.balanceUserId
+    ?? channel.platformUserId
+    ?? channel.newApiUserId
+    ?? null;
+  const parsed = parseFiniteNumber(raw);
+  if (parsed == null || parsed <= 0) return null;
+  return Math.trunc(parsed);
+}
+
+function buildUserIdHeaders(userId) {
+  if (!userId) return {};
+  const value = String(userId);
+  return {
+    'New-Api-User': value,
+    'Veloera-User': value,
+    'voapi-user': value,
+    'User-id': value,
+    'Rix-Api-User': value,
+    'neo-api-user': value
+  };
+}
+
 function buildAuthHeaders(token, extra = {}) {
   return {
     Accept: 'application/json',
@@ -30,6 +69,46 @@ function buildAuthHeaders(token, extra = {}) {
   };
 }
 
+function hasDedicatedBalanceToken(channel = {}) {
+  return !!String(
+    channel.balanceToken
+    || channel.balanceApiKey
+    || channel.balanceAuthToken
+    || ''
+  ).trim();
+}
+
+function buildCookieCandidates(token) {
+  const raw = stripBearer(token);
+  if (!raw) return [];
+
+  const candidates = [];
+  const normalized = raw.replace(/^cookie:\s*/i, '').trim();
+  if (!normalized) return [];
+  if (normalized.includes('=')) {
+    candidates.push(normalized);
+  }
+  candidates.push(`session=${normalized}`);
+  candidates.push(`token=${normalized}`);
+  return Array.from(new Set(candidates));
+}
+
+function shouldTryCookieAuth(token, channel = {}, hintedPlatform = null) {
+  const raw = stripBearer(token);
+  if (!raw) return false;
+  return hasDedicatedBalanceToken(channel)
+    || raw.includes('=')
+    || (hintedPlatform === 'anyrouter' && !isLikelyModelApiKey(raw));
+}
+
+function isLikelyModelApiKey(token) {
+  return /^sk-[a-z0-9]/i.test(stripBearer(token));
+}
+
+function isLikelyOpenRouterApiKey(token) {
+  return /^sk-or-/i.test(stripBearer(token));
+}
+
 function parseFiniteNumber(value) {
   if (typeof value === 'number' && Number.isFinite(value)) return value;
   if (typeof value === 'string') {
@@ -44,6 +123,11 @@ function roundMoney(value) {
   return Math.round(value * 1000000) / 1000000;
 }
 
+function normalizeQuotaUnit(value, fallback = QUOTA_UNIT) {
+  const parsed = parseFiniteNumber(value);
+  return parsed != null && parsed > 0 ? parsed : fallback;
+}
+
 function formatMoney(value) {
   if (!Number.isFinite(value)) return '';
   return `$${value.toFixed(2)}`;
@@ -144,7 +228,13 @@ function joinUrl(baseUrl, endpoint) {
   return `${base}${path}`;
 }
 
-function requestJson(url, { headers = {}, timeoutMs = REQUEST_TIMEOUT_MS } = {}) {
+function requestJson(url, {
+  method = 'GET',
+  headers = {},
+  body,
+  timeoutMs = REQUEST_TIMEOUT_MS,
+  redirectCount = 0
+} = {}) {
   return new Promise((resolve, reject) => {
     let parsed;
     try {
@@ -155,13 +245,21 @@ function requestJson(url, { headers = {}, timeoutMs = REQUEST_TIMEOUT_MS } = {})
     }
 
     const client = parsed.protocol === 'http:' ? http : https;
+    const requestBody = body === undefined
+      ? null
+      : (typeof body === 'string' || Buffer.isBuffer(body) ? body : JSON.stringify(body));
+    const requestHeaders = { ...headers };
+    if (requestBody != null && !Object.keys(requestHeaders).some(key => key.toLowerCase() === 'content-length')) {
+      requestHeaders['Content-Length'] = Buffer.byteLength(requestBody);
+    }
+
     const req = client.request({
       protocol: parsed.protocol,
       hostname: parsed.hostname,
       port: parsed.port,
       path: `${parsed.pathname}${parsed.search}`,
-      method: 'GET',
-      headers
+      method,
+      headers: requestHeaders
     }, (res) => {
       const chunks = [];
       let total = 0;
@@ -177,17 +275,42 @@ function requestJson(url, { headers = {}, timeoutMs = REQUEST_TIMEOUT_MS } = {})
 
       res.on('end', () => {
         const raw = Buffer.concat(chunks).toString('utf8');
+        let payload = null;
+        let parseError = null;
+        if (raw) {
+          try {
+            payload = JSON.parse(raw);
+          } catch (error) {
+            parseError = error;
+          }
+        }
+        if ([301, 302, 303, 307, 308].includes(res.statusCode) && res.headers.location && redirectCount < 3) {
+          try {
+            const nextUrl = new URL(res.headers.location, parsed).toString();
+            resolve(requestJson(nextUrl, {
+              method: res.statusCode === 303 ? 'GET' : method,
+              headers,
+              body: res.statusCode === 303 ? undefined : body,
+              timeoutMs,
+              redirectCount: redirectCount + 1
+            }));
+          } catch (error) {
+            reject(error);
+          }
+          return;
+        }
         if (res.statusCode < 200 || res.statusCode >= 300) {
           const error = new Error(`HTTP ${res.statusCode}`);
           error.statusCode = res.statusCode;
+          error.payload = payload;
           reject(error);
           return;
         }
-        try {
-          resolve(raw ? JSON.parse(raw) : null);
-        } catch (error) {
-          reject(error);
+        if (parseError) {
+          reject(parseError);
+          return;
         }
+        resolve(payload);
       });
     });
 
@@ -195,6 +318,9 @@ function requestJson(url, { headers = {}, timeoutMs = REQUEST_TIMEOUT_MS } = {})
       req.destroy(new Error('request timeout'));
     });
     req.on('error', reject);
+    if (requestBody != null) {
+      req.write(requestBody);
+    }
     req.end();
   });
 }
@@ -202,13 +328,22 @@ function requestJson(url, { headers = {}, timeoutMs = REQUEST_TIMEOUT_MS } = {})
 async function tryRequestJson(url, options) {
   try {
     return await requestJson(url, options);
-  } catch {
+  } catch (error) {
+    if (error?.payload && typeof error.payload === 'object') {
+      return error.payload;
+    }
     return null;
   }
 }
 
-function detectPlatformByUrlHint(baseUrl) {
-  const value = String(baseUrl || '').toLowerCase();
+function detectPlatformByUrlHint(...values) {
+  const value = values.map(item => String(item || '')).join(' ').toLowerCase();
+  if (value.includes('88code') || value.includes('88-code') || value.includes('rainapp.top')) return '88code';
+  if (value.includes('openrouter.ai') || value.includes('openrouter')) return 'openrouter';
+  if (value.includes('aihubmix')) return 'aihubmix';
+  if (value.includes('dashscope') || value.includes('dashscope.aliyuncs.com') || value.includes('compatible-mode')) return 'dashscope';
+  if (value.includes('modelscope') || value.includes('api-inference.modelscope.cn')) return 'modelscope';
+  if (value.includes('siliconflow') || value.includes('siliconflow.cn')) return 'siliconflow';
   if (value.includes('sub2api')) return 'sub2api';
   if (value.includes('anyrouter')) return 'anyrouter';
   if (value.includes('donehub') || value.includes('done-hub')) return 'done-hub';
@@ -220,14 +355,17 @@ function detectPlatformByUrlHint(baseUrl) {
 }
 
 function resolveStatusPlatform(payload, hintedPlatform = null) {
-  if (!payload || payload.success !== true) return null;
-  const systemName = typeof payload?.data?.system_name === 'string'
-    ? payload.data.system_name.toLowerCase()
+  if (!payload || typeof payload !== 'object') return null;
+  const data = payload.data && typeof payload.data === 'object' ? payload.data : payload;
+  const systemName = typeof data?.system_name === 'string'
+    ? data.system_name.toLowerCase()
     : '';
-  const version = typeof payload?.data?.version === 'string'
-    ? payload.data.version.toLowerCase()
+  const version = typeof data?.version === 'string'
+    ? data.version.toLowerCase()
     : '';
+  if (payload.success !== true && !systemName && !version) return null;
 
+  if (hintedPlatform === 'aihubmix' || systemName.includes('aihubmix')) return 'aihubmix';
   if (hintedPlatform === 'anyrouter') return 'anyrouter';
   if (hintedPlatform === 'done-hub') return 'done-hub';
   if (hintedPlatform === 'one-hub') return 'one-hub';
@@ -246,24 +384,15 @@ function extractSub2ApiData(payload) {
   return payload;
 }
 
-async function detectPlatform(baseUrl, token, hintedPlatform = null) {
-  const headers = buildAuthHeaders(token);
-
-  if (hintedPlatform === 'sub2api') {
-    return 'sub2api';
-  }
-
-  const status = await tryRequestJson(joinUrl(baseUrl, '/api/status'), { headers: { Accept: 'application/json' } });
-  const statusPlatform = resolveStatusPlatform(status, hintedPlatform);
-  if (statusPlatform) return statusPlatform;
-
-  const sub2Payload = await tryRequestJson(joinUrl(baseUrl, '/api/v1/auth/me'), { headers });
-  const sub2Data = extractSub2ApiData(sub2Payload);
-  if (sub2Data && Object.prototype.hasOwnProperty.call(sub2Data, 'balance')) {
-    return 'sub2api';
-  }
-
-  return hintedPlatform;
+function isSub2ApiUsagePayload(payload) {
+  if (!payload || typeof payload !== 'object') return false;
+  const mode = typeof payload.mode === 'string' ? payload.mode.trim().toLowerCase() : '';
+  if (!['quota_limited', 'unrestricted'].includes(mode)) return false;
+  return Object.prototype.hasOwnProperty.call(payload, 'remaining')
+    || Object.prototype.hasOwnProperty.call(payload, 'balance')
+    || (payload.quota && typeof payload.quota === 'object')
+    || (payload.subscription && typeof payload.subscription === 'object')
+    || (payload.usage && typeof payload.usage === 'object');
 }
 
 function extractUserSelfData(payload) {
@@ -278,7 +407,9 @@ function buildHubBalanceSnapshot(platform, payload) {
   const data = extractUserSelfData(payload);
   if (!data) return makeHiddenSnapshot(platform);
 
-  const unit = platform === 'veloera' ? VELOERA_QUOTA_UNIT : QUOTA_UNIT;
+  const unit = platform === 'veloera'
+    ? VELOERA_QUOTA_UNIT
+    : normalizeQuotaUnit(data.quota_per_unit || data.quotaPerUnit);
   const quotaRaw = parseFiniteNumber(data.quota);
   const usedRaw = parseFiniteNumber(data.used_quota);
   if (quotaRaw == null) return makeHiddenSnapshot(platform);
@@ -288,7 +419,7 @@ function buildHubBalanceSnapshot(platform, payload) {
   let remaining;
   let total;
 
-  if (platform === 'new-api' || platform === 'anyrouter' || platform === 'done-hub') {
+  if (platform === 'new-api' || platform === 'anyrouter' || platform === 'done-hub' || platform === 'aihubmix') {
     remaining = quota;
     total = quota + used;
   } else {
@@ -303,6 +434,102 @@ function buildHubBalanceSnapshot(platform, payload) {
   });
 }
 
+function extractNewApiTokenUsageData(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const data = payload.data && typeof payload.data === 'object' ? payload.data : payload;
+  if (!data || typeof data !== 'object') return null;
+  if (!Object.prototype.hasOwnProperty.call(data, 'total_available')) return null;
+  return data;
+}
+
+function buildNewApiTokenUsageSnapshot(payload, { quotaUnit = QUOTA_UNIT } = {}) {
+  const data = extractNewApiTokenUsageData(payload);
+  if (!data) return makeHiddenSnapshot('new-api');
+
+  const availableRaw = parseFiniteNumber(data.total_available);
+  if (availableRaw == null) return makeHiddenSnapshot('new-api');
+  const totalRaw = parseFiniteNumber(data.total_granted);
+  const usedRaw = parseFiniteNumber(data.total_used);
+  const unit = normalizeQuotaUnit(data.quota_per_unit || data.quotaPerUnit || quotaUnit);
+
+  const remaining = Math.max(0, availableRaw / unit);
+  return makeVisibleSnapshot('new-api', {
+    remaining,
+    used: usedRaw != null ? usedRaw / unit : undefined,
+    total: totalRaw != null ? totalRaw / unit : undefined
+  });
+}
+
+function extractOpenRouterData(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const data = payload.data && typeof payload.data === 'object' ? payload.data : payload;
+  return data && typeof data === 'object' ? data : null;
+}
+
+function buildOpenRouterKeySnapshot(payload) {
+  const data = extractOpenRouterData(payload);
+  if (!data) return makeHiddenSnapshot('openrouter');
+
+  const limitRemaining = parseFiniteNumber(data.limit_remaining ?? data.limitRemaining);
+  const limit = parseFiniteNumber(data.limit);
+  const usage = parseFiniteNumber(data.usage);
+  if (limitRemaining != null) {
+    return makeVisibleSnapshot('openrouter', {
+      remaining: Math.max(0, limitRemaining),
+      used: usage,
+      total: limit
+    });
+  }
+
+  if (limit != null && usage != null) {
+    return makeVisibleSnapshot('openrouter', {
+      remaining: Math.max(0, limit - usage),
+      used: usage,
+      total: limit
+    });
+  }
+
+  return makeHiddenSnapshot('openrouter');
+}
+
+function buildOpenRouterCreditsSnapshot(payload) {
+  const data = extractOpenRouterData(payload);
+  if (!data) return makeHiddenSnapshot('openrouter');
+
+  const totalCredits = parseFiniteNumber(data.total_credits ?? data.totalCredits);
+  const totalUsage = parseFiniteNumber(data.total_usage ?? data.totalUsage);
+  if (totalCredits == null || totalUsage == null) {
+    return makeHiddenSnapshot('openrouter');
+  }
+
+  return makeVisibleSnapshot('openrouter', {
+    remaining: Math.max(0, totalCredits - totalUsage),
+    used: totalUsage,
+    total: totalCredits
+  });
+}
+
+function buildSiliconFlowUserInfoSnapshot(payload) {
+  const data = payload?.data && typeof payload.data === 'object' ? payload.data : payload;
+  if (!data || typeof data !== 'object') return makeHiddenSnapshot('siliconflow');
+
+  const remaining = parseFiniteNumber(data.balance);
+  if (remaining == null) return makeHiddenSnapshot('siliconflow');
+  const chargeBalance = parseFiniteNumber(data.chargeBalance);
+  const totalBalance = parseFiniteNumber(data.totalBalance);
+  return makeVisibleSnapshot('siliconflow', {
+    remaining,
+    used: totalBalance != null ? Math.max(0, totalBalance - remaining) : undefined,
+    total: totalBalance ?? chargeBalance ?? remaining
+  });
+}
+
+function extractQuotaUnitFromStatus(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  const data = payload.data && typeof payload.data === 'object' ? payload.data : payload;
+  return normalizeQuotaUnit(data?.quota_per_unit || data?.quotaPerUnit, null);
+}
+
 function parseSubscriptionItems(payload) {
   const data = extractSub2ApiData(payload);
   const candidates = [
@@ -352,14 +579,460 @@ async function fetchSub2ApiSubscriptionSummary(baseUrl, headers) {
   return {};
 }
 
-async function fetchSub2ApiBalance(baseUrl, token) {
+function readSub2ApiMonthlyRemaining(subscription) {
+  if (!subscription || typeof subscription !== 'object') return null;
+  const used = readMoneyField(subscription, 'monthlyUsedUsd', 'monthly_usage_usd', 'monthly_used_usd', 'monthly_used', 'used_monthly_usd') || 0;
+  const limit = readMoneyField(subscription, 'monthlyLimitUsd', 'monthly_limit_usd', 'monthly_limit', 'limit_monthly_usd');
+  if (limit == null) return null;
+  return Math.max(0, limit - used);
+}
+
+function nonNegativeMoney(value) {
+  const parsed = parseFiniteNumber(value);
+  return parsed != null && parsed >= 0 ? parsed : null;
+}
+
+function buildSub2ApiUsageSnapshot(payload) {
+  if (!isSub2ApiUsagePayload(payload)) return makeHiddenSnapshot('sub2api');
+  if (payload.isValid === false) return makeHiddenSnapshot('sub2api');
+
+  const quota = payload.quota && typeof payload.quota === 'object' ? payload.quota : null;
+  if (quota) {
+    const remaining = nonNegativeMoney(quota.remaining) ?? nonNegativeMoney(payload.remaining);
+    if (remaining != null) {
+      return makeVisibleSnapshot('sub2api', {
+        remaining,
+        used: readMoneyField(quota, 'used', 'quota_used', 'used_usd'),
+        total: readMoneyField(quota, 'limit', 'quota', 'total')
+      });
+    }
+  }
+
+  const remaining = nonNegativeMoney(payload.balance) ?? nonNegativeMoney(payload.remaining);
+  const monthlyRemaining = readSub2ApiMonthlyRemaining(payload.subscription);
+  return makeVisibleSnapshot('sub2api', {
+    remaining,
+    monthlyRemaining
+  });
+}
+
+function addUnique(list, value) {
+  if (value && !list.includes(value)) {
+    list.push(value);
+  }
+}
+
+function toOriginApiBase(value) {
+  try {
+    const parsed = new URL(value);
+    return `${parsed.origin}/api`;
+  } catch {
+    return '';
+  }
+}
+
+function toPathApiBase(value) {
+  try {
+    const normalized = normalizeBaseUrl(value);
+    if (!normalized) return '';
+    return normalized.toLowerCase().endsWith('/api') ? normalized : joinUrl(normalized, '/api');
+  } catch {
+    return '';
+  }
+}
+
+function toOpenRouterApiBase(value) {
+  try {
+    const parsed = new URL(String(value || '').trim());
+    parsed.hash = '';
+    parsed.search = '';
+    const origin = parsed.origin;
+    const host = parsed.hostname.toLowerCase();
+    const pathname = (parsed.pathname || '').replace(/\/+$/, '');
+    const lower = pathname.toLowerCase();
+
+    if (!pathname || pathname === '/') {
+      return `${origin}/api/v1`;
+    }
+    if (lower.endsWith('/api/v1')) {
+      return `${origin}${pathname}`;
+    }
+    if (lower.endsWith('/api')) {
+      return `${origin}${pathname}/v1`;
+    }
+    if (lower.endsWith('/v1')) {
+      const parent = pathname.slice(0, -3).replace(/\/+$/, '');
+      if (!parent || parent === '') return `${origin}/api/v1`;
+      if (parent.toLowerCase().endsWith('/api')) return `${origin}${parent}/v1`;
+      return `${origin}${parent}/api/v1`;
+    }
+    if (host === 'openrouter.ai' || host.endsWith('.openrouter.ai')) {
+      return `${origin}/api/v1`;
+    }
+    return `${origin}${pathname}/api/v1`;
+  } catch {
+    return '';
+  }
+}
+
+function buildOpenRouterApiBaseCandidates(baseUrl, channel = {}) {
+  const candidates = [];
+  const inputs = [
+    channel.balanceBaseUrl,
+    channel.websiteUrl,
+    channel.baseUrl,
+    baseUrl
+  ].filter(Boolean);
+
+  for (const input of inputs) {
+    addUnique(candidates, toOpenRouterApiBase(input));
+  }
+  return candidates;
+}
+
+function buildSiliconFlowApiBaseCandidates(baseUrl, channel = {}) {
+  const candidates = [];
+  const inputs = [
+    channel.balanceBaseUrl,
+    channel.websiteUrl,
+    channel.baseUrl,
+    baseUrl
+  ].filter(Boolean);
+
+  for (const input of inputs) {
+    try {
+      const parsed = new URL(input);
+      const origin = parsed.origin;
+      const pathname = (parsed.pathname || '').replace(/\/+$/, '');
+      const lower = pathname.toLowerCase();
+      if (lower.endsWith('/v1')) {
+        addUnique(candidates, `${origin}${pathname}`);
+      } else {
+        addUnique(candidates, `${origin}/v1`);
+      }
+    } catch {}
+  }
+  return candidates;
+}
+
+function hasGatewayPathSegment(value) {
+  try {
+    const parsed = new URL(normalizeBaseUrl(value));
+    return parsed.pathname
+      .split('/')
+      .filter(Boolean)
+      .some(segment => GATEWAY_PATH_SEGMENTS.has(segment.toLowerCase()));
+  } catch {
+    return false;
+  }
+}
+
+function build88CodeApiBaseCandidates(baseUrl, channel = {}) {
+  const candidates = [];
+  const inputs = [
+    channel.balanceBaseUrl,
+    channel.websiteUrl,
+    channel.baseUrl,
+    baseUrl
+  ].filter(Boolean);
+
+  for (const input of inputs) {
+    const originApiBase = toOriginApiBase(input);
+    const pathApiBase = toPathApiBase(input);
+    if (hasGatewayPathSegment(input)) {
+      addUnique(candidates, originApiBase);
+      addUnique(candidates, pathApiBase);
+    } else {
+      addUnique(candidates, pathApiBase);
+      addUnique(candidates, originApiBase);
+    }
+  }
+  return candidates;
+}
+
+function get88CodeApiBaseFromStrategy(strategy = {}) {
+  return strategy.apiBase || strategy.baseUrl;
+}
+
+function get88CodeRequestBody(channel = {}) {
+  const model = String(
+    channel.model
+    || channel.speedTestModel
+    || channel.defaultModel
+    || ''
+  ).trim();
+  return model ? { model } : {};
+}
+
+function extract88CodeData(payload) {
+  if (!payload || typeof payload !== 'object') return null;
+  if (!Object.prototype.hasOwnProperty.call(payload, 'data')) return null;
+  return payload.data;
+}
+
+function normalize88CodeSubscription(subscription = {}) {
+  const plan = subscription.subscriptionPlan && typeof subscription.subscriptionPlan === 'object'
+    ? subscription.subscriptionPlan
+    : {};
+  const creditLimit = parseFiniteNumber(subscription.creditLimit)
+    ?? parseFiniteNumber(plan.creditLimit)
+    ?? 0;
+  return {
+    id: parseFiniteNumber(subscription.id) ?? 0,
+    planName: String(subscription.subscriptionPlanName || subscription.subscriptionName || plan.subscriptionName || ''),
+    status: String(subscription.subscriptionStatus || subscription.status || ''),
+    isActive: subscription.isActive === true,
+    remainingDays: parseFiniteNumber(subscription.remainingDays) ?? 0,
+    creditLimit,
+    currentCredits: parseFiniteNumber(subscription.currentCredits) ?? 0
+  };
+}
+
+function get88CodeBillingPriority(planName) {
+  const normalized = String(planName || '').trim().toUpperCase();
+  if (normalized === 'FREE') return 3;
+  if (normalized === 'PAYGO') return 2;
+  return 1;
+}
+
+function select88CodeSubscription(subscriptions = []) {
+  const active = subscriptions
+    .map(normalize88CodeSubscription)
+    .filter(subscription => subscription.isActive)
+    .filter(subscription => !subscription.status || subscription.status === '活跃中' || subscription.remainingDays > 0)
+    .sort((left, right) => {
+      const priorityDiff = get88CodeBillingPriority(left.planName) - get88CodeBillingPriority(right.planName);
+      if (priorityDiff !== 0) return priorityDiff;
+      return left.id - right.id;
+    });
+
+  return active.find(subscription => (
+    subscription.planName.toUpperCase() !== 'FREE'
+      && subscription.creditLimit > 0
+      && subscription.currentCredits < subscription.creditLimit
+  ))
+    || active.find(subscription => (
+      subscription.planName.toUpperCase() !== 'FREE'
+        && subscription.currentCredits > 0
+    ))
+    || null;
+}
+
+function hasOnly88CodeFreeSubscription(entities = []) {
+  const active = Array.isArray(entities)
+    ? entities.filter(item => item?.isActive === true)
+    : [];
+  if (!active.length) return false;
+  return !active.some((item) => {
+    const name = String(item.subscriptionName || item.subscriptionPlanName || '').toUpperCase();
+    return name && name !== 'FREE' && name !== 'PAYGO';
+  });
+}
+
+function build88CodeBalanceSnapshotFromValues(values = {}) {
+  const remainingRaw = parseFiniteNumber(values.currentCredits);
+  const totalRaw = parseFiniteNumber(values.creditLimit);
+  if (remainingRaw == null && totalRaw == null) {
+    return makeHiddenSnapshot('88code');
+  }
+
+  const remaining = Math.max(0, remainingRaw ?? 0);
+  const total = totalRaw != null && totalRaw > 0 ? totalRaw : undefined;
+  const used = total != null ? Math.max(0, total - remaining) : undefined;
+  return makeVisibleSnapshot('88code', {
+    remaining,
+    used,
+    total
+  });
+}
+
+function build88CodeUsageSnapshot(data) {
+  if (!data || typeof data !== 'object') return makeHiddenSnapshot('88code');
+  const entities = Array.isArray(data.subscriptionEntityList) ? data.subscriptionEntityList : [];
+  const activeEntity = entities
+    .filter(item => item?.isActive === true)
+    .filter(item => String(item.subscriptionName || '').toUpperCase() !== 'FREE')
+    .find((item) => {
+      const total = parseFiniteNumber(item.creditLimit);
+      const remaining = parseFiniteNumber(item.currentCredits);
+      return total != null && remaining != null && remaining < total;
+    });
+
+  const selected = activeEntity || data;
+  return build88CodeBalanceSnapshotFromValues({
+    creditLimit: selected.creditLimit,
+    currentCredits: selected.currentCredits
+  });
+}
+
+function is88CodeUsageDataValid(data) {
+  if (!data || typeof data !== 'object') return false;
+  const creditLimit = parseFiniteNumber(data.creditLimit) ?? 0;
+  const entities = Array.isArray(data.subscriptionEntityList) ? data.subscriptionEntityList : [];
+  return creditLimit > 0 || entities.length > 0;
+}
+
+function build88CodeSubscriptionSnapshot(payload) {
+  const data = extract88CodeData(payload);
+  const subscriptions = Array.isArray(data) ? data : [];
+  const selected = select88CodeSubscription(subscriptions);
+  if (!selected) return makeHiddenSnapshot('88code');
+  return build88CodeBalanceSnapshotFromValues({
+    creditLimit: selected.creditLimit,
+    currentCredits: selected.currentCredits
+  });
+}
+
+async function post88CodeJson(url, token, channel) {
+  return requestJson(url, {
+    method: 'POST',
+    headers: buildAuthHeaders(token, { 'Content-Type': 'application/json' }),
+    body: get88CodeRequestBody(channel)
+  });
+}
+
+async function run88CodeUsageStrategy(strategy, token, channel = {}) {
+  const apiBase = get88CodeApiBaseFromStrategy(strategy);
+  const payload = await post88CodeJson(joinUrl(apiBase, '/usage'), token, channel);
+  const usageData = extract88CodeData(payload);
+  if (!is88CodeUsageDataValid(usageData)) return makeHiddenSnapshot('88code');
+  const snapshot = build88CodeUsageSnapshot(usageData);
+  if (
+    snapshot.visible
+    && !hasOnly88CodeFreeSubscription(usageData.subscriptionEntityList)
+    && Number(snapshot.remaining || 0) > 0
+  ) {
+    return snapshot;
+  }
+  return makeHiddenSnapshot('88code');
+}
+
+async function run88CodeSubscriptionStrategy(strategy, token, channel = {}) {
+  const apiBase = get88CodeApiBaseFromStrategy(strategy);
+  const payload = await post88CodeJson(joinUrl(apiBase, '/subscription'), token, channel);
+  return build88CodeSubscriptionSnapshot(payload);
+}
+
+function buildBalanceProbeStrategies(baseUrl, channel = {}, token = '') {
+  const hintedPlatform = detectPlatformByUrlHint(
+    channel.providerKey,
+    channel.name,
+    channel.websiteUrl,
+    channel.baseUrl || baseUrl
+  );
+  const strategies = [];
+  const seen = new Set();
+  const add = (strategy) => {
+    const key = JSON.stringify(strategy);
+    if (!seen.has(key)) {
+      seen.add(key);
+      strategies.push(strategy);
+    }
+  };
+  const addSub2ApiStrategies = () => {
+    if (isLikelyModelApiKey(token)) {
+      add({ type: 'sub2api-usage', baseUrl });
+    } else {
+      add({ type: 'sub2api-auth', baseUrl });
+      add({ type: 'sub2api-usage', baseUrl });
+    }
+  };
+  const addHubStrategy = () => {
+    add({
+      type: 'hub-user-self',
+      baseUrl,
+      platform: HUB_PLATFORMS.has(hintedPlatform) ? hintedPlatform : null,
+      hintedPlatform,
+      userId: resolveBalanceUserId(channel),
+      allowCookieAuth: shouldTryCookieAuth(token, channel, hintedPlatform)
+    });
+  };
+  const addNewApiTokenUsageStrategy = () => {
+    add({ type: 'new-api-token-usage', baseUrl });
+  };
+  const addNewApiTokenUsageWithStatusStrategy = () => {
+    add({ type: 'new-api-token-usage-status', baseUrl });
+  };
+  const add88CodeStrategies = () => {
+    for (const apiBase of build88CodeApiBaseCandidates(baseUrl, channel)) {
+      add({ type: '88code-usage', baseUrl, apiBase });
+      add({ type: '88code-subscription', baseUrl, apiBase });
+    }
+  };
+  const addOpenRouterStrategies = () => {
+    for (const apiBase of buildOpenRouterApiBaseCandidates(baseUrl, channel)) {
+      add({ type: 'openrouter-key', baseUrl, apiBase, endpoint: '/key' });
+      add({ type: 'openrouter-key', baseUrl, apiBase, endpoint: '/auth/key' });
+      add({ type: 'openrouter-credits', baseUrl, apiBase });
+    }
+  };
+  const addSiliconFlowStrategies = () => {
+    for (const apiBase of buildSiliconFlowApiBaseCandidates(baseUrl, channel)) {
+      add({ type: 'siliconflow-user-info', baseUrl, apiBase });
+    }
+  };
+
+  if (UNSUPPORTED_BALANCE_PLATFORMS.has(hintedPlatform)) {
+    add({ type: 'unsupported-balance', platform: hintedPlatform, baseUrl });
+    return strategies;
+  }
+
+  if (hintedPlatform === 'siliconflow') {
+    addSiliconFlowStrategies();
+    return strategies;
+  }
+
+  if (hintedPlatform === '88code') {
+    add88CodeStrategies();
+    addSub2ApiStrategies();
+    addHubStrategy();
+    return strategies;
+  }
+
+  if (hintedPlatform === 'openrouter' || isLikelyOpenRouterApiKey(token)) {
+    addOpenRouterStrategies();
+    addSub2ApiStrategies();
+    addNewApiTokenUsageWithStatusStrategy();
+    addHubStrategy();
+    return strategies;
+  }
+
+  if (hintedPlatform === 'sub2api') {
+    addSub2ApiStrategies();
+    addNewApiTokenUsageWithStatusStrategy();
+    addHubStrategy();
+    return strategies;
+  }
+
+  if (HUB_PLATFORMS.has(hintedPlatform)) {
+    if (hintedPlatform === 'new-api') {
+      addNewApiTokenUsageWithStatusStrategy();
+    }
+    addHubStrategy();
+    addSub2ApiStrategies();
+    return strategies;
+  }
+
+  if (isLikelyModelApiKey(token)) {
+    addSub2ApiStrategies();
+    addNewApiTokenUsageWithStatusStrategy();
+    addHubStrategy();
+  } else {
+    addHubStrategy();
+    addNewApiTokenUsageWithStatusStrategy();
+    addSub2ApiStrategies();
+  }
+  return strategies;
+}
+
+async function runSub2ApiAuthStrategy(strategy, token) {
   const headers = buildAuthHeaders(token);
-  const payload = await requestJson(joinUrl(baseUrl, '/api/v1/auth/me'), { headers });
+  const payload = await tryRequestJson(joinUrl(strategy.baseUrl, '/api/v1/auth/me'), { headers });
   const data = extractSub2ApiData(payload);
   const balance = parseFiniteNumber(data?.balance);
   if (balance == null) return makeHiddenSnapshot('sub2api');
 
-  const summary = await fetchSub2ApiSubscriptionSummary(baseUrl, headers);
+  const summary = await fetchSub2ApiSubscriptionSummary(strategy.baseUrl, headers);
   return makeVisibleSnapshot('sub2api', {
     remaining: balance,
     used: 0,
@@ -368,33 +1041,212 @@ async function fetchSub2ApiBalance(baseUrl, token) {
   });
 }
 
-async function fetchHubBalance(baseUrl, token, platform) {
-  const headers = buildAuthHeaders(token);
-  const payload = await requestJson(joinUrl(baseUrl, '/api/user/self'), { headers });
-  return buildHubBalanceSnapshot(platform, payload);
+async function runSub2ApiUsageStrategy(strategy, token) {
+  const payload = await tryRequestJson(joinUrl(strategy.baseUrl, '/v1/usage'), {
+    headers: buildAuthHeaders(token)
+  });
+  return buildSub2ApiUsageSnapshot(payload);
 }
 
-async function fetchBalanceFromBase(baseUrl, channel) {
-  const token = stripBearer(channel.apiKey || channel.token || channel.authToken || '');
-  if (!baseUrl || !token) return makeHiddenSnapshot();
+async function fetchHubUserSelfWithCookie(baseUrl, token, platform, quotaUnit, userId) {
+  for (const cookie of buildCookieCandidates(token)) {
+    const payload = await tryRequestJson(joinUrl(baseUrl, '/api/user/self'), {
+      headers: {
+        Accept: 'application/json',
+        Cookie: cookie,
+        ...buildUserIdHeaders(userId)
+      }
+    });
+    const snapshot = buildHubBalanceSnapshot(platform, {
+      ...payload,
+      data: payload?.data && typeof payload.data === 'object'
+        ? { ...payload.data, quota_per_unit: quotaUnit || payload.data.quota_per_unit }
+        : payload?.data
+    });
+    if (snapshot.visible) return snapshot;
+  }
+  return makeHiddenSnapshot(platform);
+}
 
-  const hintedPlatform = detectPlatformByUrlHint(channel.baseUrl || baseUrl);
-  const platform = await detectPlatform(baseUrl, token, hintedPlatform);
-  if (!platform) return makeHiddenSnapshot();
+async function runHubUserSelfStrategy(strategy, token) {
+  const userId = strategy.userId || null;
+  const headers = buildAuthHeaders(token, buildUserIdHeaders(userId));
+  let platform = strategy.platform;
+  let quotaUnit = null;
+  if (!HUB_PLATFORMS.has(platform)) {
+    const status = await tryRequestJson(joinUrl(strategy.baseUrl, '/api/status'), { headers: { Accept: 'application/json' } });
+    platform = resolveStatusPlatform(status, strategy.hintedPlatform);
+    quotaUnit = extractQuotaUnitFromStatus(status);
+  }
+  if (!HUB_PLATFORMS.has(platform)) return { snapshot: makeHiddenSnapshot(platform), strategy };
 
-  if (platform === 'sub2api') {
-    return fetchSub2ApiBalance(baseUrl, token);
+  let snapshot = makeHiddenSnapshot(platform);
+  try {
+    const payload = await requestJson(joinUrl(strategy.baseUrl, '/api/user/self'), { headers });
+    snapshot = buildHubBalanceSnapshot(platform, {
+      ...payload,
+      data: payload?.data && typeof payload.data === 'object'
+        ? { ...payload.data, quota_per_unit: quotaUnit || payload.data.quota_per_unit }
+        : payload?.data
+    });
+  } catch (error) {
+    if (!strategy.allowCookieAuth) throw error;
+  }
+  if (!snapshot.visible && strategy.allowCookieAuth) {
+    snapshot = await fetchHubUserSelfWithCookie(strategy.baseUrl, token, platform, quotaUnit, userId);
   }
+  return {
+    snapshot,
+    strategy: {
+      ...strategy,
+      platform,
+      quotaUnit: quotaUnit || strategy.quotaUnit
+    }
+  };
+}
+
+async function runNewApiTokenUsageStrategy(strategy, token) {
+  const payload = await requestJson(joinUrl(strategy.baseUrl, '/api/usage/token'), {
+    headers: buildAuthHeaders(token)
+  });
+  return buildNewApiTokenUsageSnapshot(payload, { quotaUnit: strategy.quotaUnit || QUOTA_UNIT });
+}
 
-  if (['new-api', 'one-api', 'one-hub', 'done-hub', 'veloera', 'anyrouter'].includes(platform)) {
-    return fetchHubBalance(baseUrl, token, platform);
+async function runNewApiTokenUsageWithStatusStrategy(strategy, token) {
+  const status = await tryRequestJson(joinUrl(strategy.baseUrl, '/api/status'), {
+    headers: { Accept: 'application/json' }
+  });
+  const quotaUnit = extractQuotaUnitFromStatus(status) || QUOTA_UNIT;
+  const snapshot = await runNewApiTokenUsageStrategy({ ...strategy, quotaUnit }, token);
+  return {
+    snapshot,
+    strategy: {
+      ...strategy,
+      quotaUnit
+    }
+  };
+}
+
+async function runOpenRouterKeyStrategy(strategy, token) {
+  const payload = await requestJson(joinUrl(strategy.apiBase || strategy.baseUrl, strategy.endpoint || '/key'), {
+    headers: buildAuthHeaders(token)
+  });
+  return buildOpenRouterKeySnapshot(payload);
+}
+
+async function runOpenRouterCreditsStrategy(strategy, token) {
+  const payload = await requestJson(joinUrl(strategy.apiBase || strategy.baseUrl, '/credits'), {
+    headers: buildAuthHeaders(token)
+  });
+  return buildOpenRouterCreditsSnapshot(payload);
+}
+
+async function runSiliconFlowUserInfoStrategy(strategy, token) {
+  const payload = await requestJson(joinUrl(strategy.apiBase || strategy.baseUrl, '/user/info'), {
+    headers: buildAuthHeaders(token)
+  });
+  return buildSiliconFlowUserInfoSnapshot(payload);
+}
+
+async function runBalanceStrategy(strategy, token, channel = {}) {
+  if (!strategy || !strategy.type) {
+    return { snapshot: makeHiddenSnapshot(), strategy };
   }
 
-  return makeHiddenSnapshot(platform);
+  if (strategy.type === '88code-usage') {
+    return {
+      snapshot: await run88CodeUsageStrategy(strategy, token, channel),
+      strategy
+    };
+  }
+  if (strategy.type === '88code-subscription') {
+    return {
+      snapshot: await run88CodeSubscriptionStrategy(strategy, token, channel),
+      strategy
+    };
+  }
+  if (strategy.type === 'sub2api-auth') {
+    return {
+      snapshot: await runSub2ApiAuthStrategy(strategy, token),
+      strategy
+    };
+  }
+  if (strategy.type === 'sub2api-usage') {
+    return {
+      snapshot: await runSub2ApiUsageStrategy(strategy, token),
+      strategy
+    };
+  }
+  if (strategy.type === 'hub-user-self') {
+    return runHubUserSelfStrategy(strategy, token);
+  }
+  if (strategy.type === 'new-api-token-usage') {
+    return {
+      snapshot: await runNewApiTokenUsageStrategy(strategy, token),
+      strategy
+    };
+  }
+  if (strategy.type === 'new-api-token-usage-status') {
+    return runNewApiTokenUsageWithStatusStrategy(strategy, token);
+  }
+  if (strategy.type === 'openrouter-key') {
+    return {
+      snapshot: await runOpenRouterKeyStrategy(strategy, token),
+      strategy
+    };
+  }
+  if (strategy.type === 'openrouter-credits') {
+    return {
+      snapshot: await runOpenRouterCreditsStrategy(strategy, token),
+      strategy
+    };
+  }
+  if (strategy.type === 'unsupported-balance') {
+    return {
+      snapshot: makeHiddenSnapshot(strategy.platform),
+      strategy
+    };
+  }
+  if (strategy.type === 'siliconflow-user-info') {
+    return {
+      snapshot: await runSiliconFlowUserInfoStrategy(strategy, token),
+      strategy
+    };
+  }
+
+  return { snapshot: makeHiddenSnapshot(), strategy };
+}
+
+async function tryBalanceStrategy(strategy, token, channel = {}) {
+  try {
+    const result = await runBalanceStrategy(strategy, token, channel);
+    if (result?.snapshot?.visible) return result;
+  } catch {
+    // Probe errors are intentionally silent; unsupported balances stay hidden.
+  }
+  return null;
+}
+
+async function probeBalanceFromBase(baseUrl, channel, token) {
+  let lastSnapshot = null;
+  for (const strategy of buildBalanceProbeStrategies(baseUrl, channel, token)) {
+    const result = await tryBalanceStrategy(strategy, token, channel);
+    if (result) return result;
+    if (!lastSnapshot) {
+      lastSnapshot = makeHiddenSnapshot(
+        strategy.type?.startsWith('88code') ? '88code'
+          : strategy.type?.startsWith('openrouter') ? 'openrouter'
+          : strategy.type?.startsWith('siliconflow') ? 'siliconflow'
+          : strategy.type?.startsWith('sub2api') ? 'sub2api'
+            : strategy.platform || null
+      );
+    }
+  }
+  return lastSnapshot ? { snapshot: lastSnapshot, strategy: null } : null;
 }
 
 function buildCacheKey(source, channel) {
-  const token = stripBearer(channel.apiKey || channel.token || channel.authToken || '');
+  const token = resolveBalanceToken(channel);
   const tokenHash = token
     ? crypto.createHash('sha256').update(token).digest('hex').slice(0, 16)
     : 'no-token';
@@ -417,25 +1269,37 @@ async function refreshChannelBalanceSnapshot(source, channel, options = {}) {
   }
 
   const bases = buildBaseCandidates(channel.baseUrl);
-  if (!bases.length || !stripBearer(channel.apiKey || channel.token || channel.authToken || '')) {
+  if (!bases.length || !resolveBalanceToken(channel)) {
     return makeHiddenSnapshot(null, { updatedAt: nowIso(currentTime) });
   }
 
   let lastSnapshot = null;
+  const token = resolveBalanceToken(channel);
+  const cachedStrategy = balanceStrategyCache.get(key);
+  if (cachedStrategy) {
+    const strategyResult = await tryBalanceStrategy(cachedStrategy, token, channel);
+    if (strategyResult?.snapshot?.visible) {
+      balanceStrategyCache.set(key, strategyResult.strategy);
+      balanceCache.set(key, {
+        snapshot: strategyResult.snapshot,
+        expiresAt: currentTime + CACHE_TTL_MS
+      });
+      return strategyResult.snapshot;
+    }
+    balanceStrategyCache.delete(key);
+  }
+
   for (const baseUrl of bases) {
-    try {
-      const snapshot = await fetchBalanceFromBase(baseUrl, channel);
-      if (snapshot?.visible) {
-        balanceCache.set(key, {
-          snapshot,
-          expiresAt: currentTime + CACHE_TTL_MS
-        });
-        return snapshot;
-      }
-      lastSnapshot = snapshot || lastSnapshot;
-    } catch {
-      // Try the next normalized base candidate.
+    const result = await probeBalanceFromBase(baseUrl, channel, token);
+    if (result?.snapshot?.visible) {
+      balanceStrategyCache.set(key, result.strategy);
+      balanceCache.set(key, {
+        snapshot: result.snapshot,
+        expiresAt: currentTime + CACHE_TTL_MS
+      });
+      return result.snapshot;
     }
+    lastSnapshot = result?.snapshot || makeHiddenSnapshot(null, { updatedAt: nowIso(currentTime) });
   }
 
   if (cached?.snapshot?.visible) {
@@ -543,6 +1407,7 @@ async function refreshChannelBalance(source, channelId) {
 
 function clearBalanceCache() {
   balanceCache.clear();
+  balanceStrategyCache.clear();
 }
 
 module.exports = {
@@ -553,8 +1418,24 @@ module.exports = {
     normalizeBaseUrl,
     buildBaseCandidates,
     buildHubBalanceSnapshot,
+    buildNewApiTokenUsageSnapshot,
+    buildOpenRouterKeySnapshot,
+    buildOpenRouterCreditsSnapshot,
+    buildSiliconFlowUserInfoSnapshot,
     detectPlatformByUrlHint,
+    isSub2ApiUsagePayload,
+    buildSub2ApiUsageSnapshot,
     resolveStatusPlatform,
+    resolveBalanceToken,
+    resolveBalanceUserId,
+    buildCookieCandidates,
+    build88CodeApiBaseCandidates,
+    buildOpenRouterApiBaseCandidates,
+    buildSiliconFlowApiBaseCandidates,
+    build88CodeUsageSnapshot,
+    build88CodeSubscriptionSnapshot,
+    buildBalanceProbeStrategies,
+    runBalanceStrategy,
     refreshChannelBalanceSnapshot,
     makeVisibleSnapshot,
     requestJson