@apinggithub/mydsh-auto-model-router 0.3.0 → 0.3.1

package/config.mjs

@@ -22,7 +22,7 @@
 //   fallbackChain:  [route, ...]  (model-level, appended with the default)
 //   maxRetries:     per-route retry budget on request-error
 
-export const PLUGIN_VERSION = '0.3.0'
+export const PLUGIN_VERSION = '0.3.1'
 
 export const LEVEL_IDS = Object.freeze(['L0', 'L1', 'L2', 'L3'])
 export const COST_MODES = Object.freeze(['cost-first', 'quality-first', 'balanced'])
@@ -130,6 +130,12 @@ const DEFAULT_CONFIG = Object.freeze({
     balanceFloorCny: 10,
     // Retire a route whose model shows any spend in the current billing cycle.
     demoteOnSpend: true,
+    // Per-provider floor for DeepSeek's own platform balance (`/user/balance`),
+    // which no cloud bill covers. 0 disables it.
+    deepseekBalanceFloor: 0,
+    deepseekApiKeyRef: 'DEEPSEEK_API_KEY',
+    deepseekProvider: 'deepseek-official',
+    deepseekEndpoint: 'https://api.deepseek.com/user/balance',
     // Credential refs resolved through ctx.credentials (never inline secrets).
     accessKeyIdRef: 'ALIBABA_CLOUD_ACCESS_KEY_ID',
     accessKeySecretRef: 'ALIBABA_CLOUD_ACCESS_KEY_SECRET',
@@ -296,6 +302,22 @@ function normalizeQuotaWatch(quotaWatch) {
     ? Number(q.balanceFloorCny)
     : DEFAULT_CONFIG.quotaWatch.balanceFloorCny
   q.timeoutMs = clampInt(q.timeoutMs, 5_000, 120_000, DEFAULT_CONFIG.quotaWatch.timeoutMs)
+  q.deepseekBalanceFloor = Number.isFinite(Number(q.deepseekBalanceFloor)) && Number(q.deepseekBalanceFloor) >= 0
+    ? Number(q.deepseekBalanceFloor)
+    : DEFAULT_CONFIG.quotaWatch.deepseekBalanceFloor
+  q.deepseekApiKeyRef = String(q.deepseekApiKeyRef ?? '').trim()
+  q.deepseekProvider = String(q.deepseekProvider ?? '').trim()
+  q.deepseekEndpoint = String(q.deepseekEndpoint ?? '').trim() || DEFAULT_CONFIG.quotaWatch.deepseekEndpoint
+  if (q.deepseekBalanceFloor > 0) {
+    for (const [field, value] of [
+      ['deepseekApiKeyRef', q.deepseekApiKeyRef],
+      ['deepseekProvider', q.deepseekProvider],
+    ]) {
+      if (value === '') {
+        throw new Error(`mydsh-auto-model-router: quotaWatch.${field} must be a non-empty string when deepseekBalanceFloor is set`)
+      }
+    }
+  }
   if (q.enabled) {
     for (const [field, value] of [
       ['provider', q.provider],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apinggithub/mydsh-auto-model-router",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Hybrid model router for DeepSeek Harness: declarative rules, user-configurable cost control (cost-first / quality-first / balanced), optional LLM task classifier, and failure fallback chains.",
   "type": "module",
   "main": "index.mjs",

package/quota-watch.mjs

@@ -102,6 +102,40 @@ export async function fetchBalance({ accessKeyId, accessKeySecret, timeoutMs = 2
   }
 }
 
+/**
+ * Read the DeepSeek platform balance (`GET /user/balance`).
+ *
+ * The `deepseek-official` provider bills against that account rather than any
+ * cloud bill, so it needs its own floor: the Aliyun watch cannot see it.
+ *
+ * @param {object} options
+ * @param {string} options.apiKey
+ * @param {string} [options.endpoint]
+ * @param {number} [options.timeoutMs]
+ * @param {Function} [options.fetchImpl]
+ */
+export async function fetchDeepSeekBalance({
+  apiKey,
+  endpoint = 'https://api.deepseek.com/user/balance',
+  timeoutMs = 20_000,
+  fetchImpl = fetch,
+}) {
+  const response = await fetchImpl(endpoint, {
+    headers: { authorization: `Bearer ${apiKey}` },
+    signal: AbortSignal.timeout(timeoutMs),
+  })
+  const body = JSON.parse(await response.text())
+  const infos = Array.isArray(body?.balance_infos) ? body.balance_infos : []
+  const cny = infos.find((info) => info?.currency === 'CNY') ?? infos[0]
+  return {
+    available: body?.is_available !== false,
+    totalCny: Number(cny?.total_balance ?? 0),
+    grantedCny: Number(cny?.granted_balance ?? 0),
+    toppedUpCny: Number(cny?.topped_up_balance ?? 0),
+    currency: cny?.currency ?? 'CNY',
+  }
+}
+
 /** Read one billing cycle, following NextToken until exhausted. */
 export async function fetchBill({
   accessKeyId,
@@ -146,6 +180,7 @@ export function createQuotaWatch({ config, router, credentials, logger, fetchImp
   let running = false
   const retired = new Set()
   let balanceWarned = false
+  let deepseekWarned = false
   let snapshot = {
     enabled: config.enabled === true,
     lastCheckAt: null,
@@ -156,6 +191,9 @@ export function createQuotaWatch({ config, router, credentials, logger, fetchImp
     totalCny: null,
     exhausted: [],
     balanceLow: false,
+    deepseekBalanceCny: null,
+    deepseekBlocked: false,
+    deepseekError: null,
   }
 
   async function readSecret(ref) {
@@ -201,6 +239,38 @@ export function createQuotaWatch({ config, router, credentials, logger, fetchImp
         }
       }
 
+      // DeepSeek bills against its own platform account, which the cloud bill
+      // never covers: give that provider its own floor.
+      let deepseekBalance = null
+      let deepseekError = null
+      const dsFloor = Number(config.deepseekBalanceFloor) || 0
+      if (dsFloor > 0) {
+        try {
+          const apiKey = await readSecret(config.deepseekApiKeyRef)
+          deepseekBalance = await fetchDeepSeekBalance({
+            apiKey,
+            endpoint: config.deepseekEndpoint,
+            timeoutMs: config.timeoutMs,
+            fetchImpl,
+          })
+          const blocked = deepseekBalance.totalCny < dsFloor
+          router.setProviderBlocked(config.deepseekProvider, blocked)
+          if (blocked && !deepseekWarned) {
+            deepseekWarned = true
+            logger?.warn?.(
+              `[mydsh-auto-model-router] ${config.deepseekProvider} balance ¥${deepseekBalance.totalCny.toFixed(2)} `
+              + `is below the ¥${dsFloor} floor: that provider is paused`,
+            )
+          } else if (!blocked && deepseekWarned) {
+            deepseekWarned = false
+            logger?.info?.(`[mydsh-auto-model-router] ${config.deepseekProvider} balance recovered: provider resumed`)
+          }
+        } catch (error) {
+          deepseekError = String(error?.message ?? error)
+          logger?.warn?.(`[mydsh-auto-model-router] deepseek balance check failed: ${deepseekError}`)
+        }
+      }
+
       if (config.demoteOnSpend) {
         for (const route of guardedRoutes()) {
           const spend = bill.byModel[route.model]
@@ -227,6 +297,9 @@ export function createQuotaWatch({ config, router, credentials, logger, fetchImp
         totalCny: bill.total,
         exhausted: router.exhaustedRouteKeys(),
         balanceLow: router.isBalanceLow(),
+        deepseekBalanceCny: deepseekBalance?.totalCny ?? null,
+        deepseekBlocked: router.isProviderBlocked(config.deepseekProvider),
+        deepseekError,
       }
     } catch (error) {
       snapshot = { ...snapshot, lastCheckAt: now().toISOString(), lastError: String(error?.message ?? error) }

package/router.mjs

@@ -67,6 +67,8 @@ export class ModelRouter {
     this.exhaustedRoutes = new Set()
     /** True while the account balance sits below the configured floor. */
     this.balanceLow = false
+    /** Providers paused by a per-provider balance floor (e.g. deepseek-official). */
+    this.blockedProviders = new Set()
     /** @type {Map<string, object>} */
     this.states = new Map()
   }
@@ -274,6 +276,28 @@ export class ModelRouter {
     return this.balanceLow === true
   }
 
+  /**
+   * Pause every route of one provider (a provider whose own balance is below
+   * its floor). The rest of the ladder keeps working.
+   * @param {string} provider
+   * @param {boolean} blocked
+   */
+  setProviderBlocked(provider, blocked) {
+    if (typeof provider !== 'string' || provider === '') return
+    if (blocked) this.blockedProviders.add(provider)
+    else this.blockedProviders.delete(provider)
+  }
+
+  /** Whether a provider is paused by its own balance floor. */
+  isProviderBlocked(provider) {
+    return this.blockedProviders.has(provider)
+  }
+
+  /** Every provider currently paused, for the status report. */
+  blockedProviderList() {
+    return [...this.blockedProviders]
+  }
+
   /**
    * Whether this route must not be dispatched to right now.
    * @param {object} route
@@ -282,6 +306,7 @@ export class ModelRouter {
   routeBlocked(route) {
     if (!route) return true
     if (this.isRouteExhausted(route)) return true
+    if (this.isProviderBlocked(route.provider)) return true
     if (this.balanceLow && !this.isFreeRoute(route)) return true
     return false
   }