@goodandready/dsh-subscriptions 0.6.37 → 0.6.39

package/lib/accounts.js

@@ -1,3 +1,4 @@
+import { needsWarmupProbe, enterProbing, resolveWarmupSuccess, resolveWarmupFailure, STATUS_QUARANTINE, STATUS_PROBING } from "./quarantine.js"
 import { fetchWithTimeout } from "./http.js"
 import { credentialRef } from '@deepseek-ai/dsh-credentials'
 import { oauthRef, isProvider } from './refs.js'
@@ -13,7 +14,6 @@ export function normalizeSlots(slots) {
   const out = []
   const seen = new Set()
   for (const slot of Array.isArray(slots) ? slots : []) {
-    // User-editable config: a null or non-object entry must be skipped, not crash the plugin.
     if (!slot || typeof slot !== 'object') continue
     if (!isProvider(slot.provider)) continue
     const index = Number(slot.index)
@@ -22,10 +22,13 @@ export function normalizeSlots(slots) {
     if (seen.has(ref)) continue
     seen.add(ref)
     out.push({
+      ...slot,
       provider: slot.provider,
       index,
       label: String(slot.label || ''),
       ref,
+      ...(slot.proxyUrl ? { proxyUrl: String(slot.proxyUrl) } : {}),
+      ...(slot.expiresAt ? { expiresAt: Number(slot.expiresAt) } : {}),
     })
   }
   return out
@@ -94,16 +97,27 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   }
 
   async function saveBlob(ref, blob) {
+    if (!ref || typeof ref !== "string") throw new Error("invalid ref for saveBlob")
     const prev = writeQueues.get(ref) || Promise.resolve()
     const next = prev.catch(() => {}).then(async () => {
-      await credentials.set(credentialRef(ref), serializeBlob(blob))
+      try {
+        await credentials.set(credentialRef(ref), serializeBlob(blob))
+      } catch (err) {
+        const wrapErr = new Error(`failed to persist credentials for ${ref}: ${err && err.message || err}`)
+        wrapErr.code = "CREDENTIAL_SAVE_FAILED"
+        wrapErr.cause = err
+        throw wrapErr
+      }
     })
     writeQueues.set(ref, next)
     await next
   }
 
   async function clearRef(ref) {
-    await credentials.unset(credentialRef(ref))
+    if (!ref || typeof ref !== "string") return
+    try {
+      await credentials.unset(credentialRef(ref))
+    } catch { /* best-effort unset */ }
     cooldowns.delete(ref)
     quotas.delete(ref)
     quarantines.delete(ref)
@@ -202,6 +216,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
   }
 
   async function ensureFresh(provider, blob, ref) {
+    if (!blob || typeof blob !== 'object') return blob
+    if (blob.apiKeyOnly || (blob.apiKey && (!blob.refreshToken || blob.refreshToken === blob.apiKey))) return blob
     if (!blob.refreshToken) return blob
     if (blob.expiresAt && blob.expiresAt - SKEW_MS > Date.now()) return blob
     const lockKey = ref || (provider + ":" + (blob.accountId || blob.email || (blob.refreshToken && blob.refreshToken.slice(-16)) || "anon"))
@@ -333,19 +349,51 @@ export function createAccountStore({ credentials, getConfig, fetchImpl, fetchFor
       quarantines.delete(ref)
       if (health.has(ref)) health.set(ref, null)
     },
-    rememberQuarantine(ref, reason, until) {
+    rememberQuarantine(ref, reason, until, attempts = 1) {
       if (!ref) return
-      quarantines.set(ref, { reason: reason || 'RATE_LIMIT', until: Number(until) || (Date.now() + 3600000) })
+      quarantines.set(ref, {
+        reason: reason || 'RATE_LIMIT',
+        until: Number(until) || (Date.now() + 3600000),
+        attempts: Number(attempts) || 1,
+        status: STATUS_QUARANTINE,
+      })
     },
-    getQuarantine(ref) {
+    getQuarantine(ref, now = Date.now()) {
       const q = quarantines.get(ref)
       if (!q) return null
-      if (Number(q.until) <= Date.now()) {
+      if (Number(q.until) <= now) {
+        if (q.status === STATUS_PROBING) return q
         quarantines.delete(ref)
         return null
       }
       return q
     },
+    async probeWarmup(ref, probeFn) {
+      const q = quarantines.get(ref)
+      if (!q) return { success: true }
+      const acc = { quarantineReason: q.reason, quarantineUntil: q.until, quarantineAttempts: q.attempts || 1, status: q.status }
+      if (!needsWarmupProbe(acc)) {
+        return { success: false, reason: 'NOT_EXPIRED' }
+      }
+      quarantines.set(ref, enterProbing(acc))
+      try {
+        if (typeof probeFn === 'function') {
+          await probeFn(ref)
+        }
+        resolveWarmupSuccess(acc)
+        quarantines.delete(ref)
+        return { success: true }
+      } catch (err) {
+        const updated = resolveWarmupFailure(acc, err?.message || q.reason)
+        quarantines.set(ref, {
+          reason: updated.quarantineReason,
+          until: updated.quarantineUntil,
+          attempts: updated.quarantineAttempts,
+          status: updated.status,
+        })
+        return { success: false, account: updated, error: err }
+      }
+    },
     releaseQuarantine(ref) {
       quarantines.delete(ref)
     },

package/lib/adapter-manager.js

@@ -21,6 +21,7 @@ export function createAdapterManager({
 }) {
   let handle
   let adapterDisposed = false
+  let retryTimer
   let registeredByUs = new Set()
 
   function disposeAdapterHandle(h) {
@@ -48,6 +49,11 @@ export function createAdapterManager({
     saveBlob: (ref, blob) => store.saveBlob(ref, blob),
     alertThresholds: () => live().alertThresholds,
     webhookUrl: () => live().webhookUrl,
+    rememberRequest: (ref) => store.rememberRequest(ref),
+    recordSuccess: (ref) => store.recordSuccess(ref),
+    recordSwitch: (ref) => store.recordSwitch(ref),
+    recordExhaust: (ref) => store.recordExhaust(ref),
+    recordBroken: (ref) => store.recordBroken(ref),
     recordHistory,
     fetchImpl: fetch,
     fetchForRef,
@@ -83,6 +89,7 @@ export function createAdapterManager({
   async function syncAdapter() {
     if (adapterDisposed) return
     const desired = await store.loggedInProviders()
+    if (adapterDisposed) return
     const globalProviders = ctx.llm && typeof ctx.llm.listProviders === 'function'
       ? ctx.llm.listProviders().map((p) => p.id)
       : []
@@ -95,6 +102,7 @@ export function createAdapterManager({
       logger.info(`[dsh-subscriptions] syncAdapter skipping already-bound providers: ${skipped.join(', ')}`)
     }
 
+    if (adapterDisposed) return
     if (!handle && claimable.length) {
       handle = ctx.llm.registerAdapter(claimable, adapter)
       registeredByUs = new Set(claimable)
@@ -202,6 +210,8 @@ export function createAdapterManager({
   }
 
   let lastModelRefresh = 0
+  const providerModelCache = new Map()
+
   async function refreshModels() {
     if (Date.now() - lastModelRefresh < 60 * 1000) return
     lastModelRefresh = Date.now()
@@ -214,7 +224,10 @@ export function createAdapterManager({
         if (!blob) continue
         const fresh = await store.ensureFresh(provider, blob, slot.ref)
         const cfg = vendorConfig(provider, live())
-        await getVendor(provider).listModels(fresh, cfg, fetch).catch(() => {})
+        const liveModels = await getVendor(provider).listModels(fresh, cfg, fetch).catch(() => null)
+        if (Array.isArray(liveModels) && liveModels.length) {
+          providerModelCache.set(provider, liveModels)
+        }
       } catch { /* best-effort */ }
     }
   }
@@ -234,7 +247,6 @@ export function createAdapterManager({
       })
 
       let retries = 0
-      let retryTimer
       const scheduleRetry = () => {
         if (adapterDisposed || retries >= 30) return
         retryTimer = setTimeout(retrySync, 1000)
@@ -298,5 +310,15 @@ export function createAdapterManager({
     refreshModels,
     cascadeFallbackStream,
     registerAdapterLifecycle,
+    dispose: () => {
+      adapterDisposed = true
+      adapter.dispose()
+      if (retryTimer) clearTimeout(retryTimer)
+      if (handle) {
+        disposeAdapterHandle(handle)
+        handle = undefined
+        registeredByUs.clear()
+      }
+    },
   }
 }

package/lib/adapter.js

@@ -32,6 +32,11 @@ export class SubscriptionAdapter extends LlmAdapter {
   constructor(deps) {
     super()
     this.deps = deps
+    this.disposed = false
+  }
+
+  dispose() {
+    this.disposed = true
   }
 
   providerInfo(provider) {
@@ -45,20 +50,24 @@ export class SubscriptionAdapter extends LlmAdapter {
   async listModels(provider) {
     const accounts = await this.deps.listAccounts(provider)
     const targetAccount = accounts.find((a) => a.hasToken)
-    if (!targetAccount) return []
-    const cfg = this.deps.vendorConfig(provider)
-    const fetchImpl = pickFetch(this.deps, targetAccount.ref)
     let models = null
-    try {
-      const blob = await this.deps.ensureFresh(
-        provider,
-        await this.deps.loadBlob(targetAccount.ref),
-        targetAccount.ref,
-      )
-      const live = await getVendor(provider).listModels(blob, cfg, fetchImpl)
-      if (Array.isArray(live) && live.length) models = live
-    } catch { /* use built-in catalog */ }
-    if (!models) models = modelCatalog(provider, cfg.models)
+    if (targetAccount) {
+      const cfg = this.deps.vendorConfig(provider)
+      const fetchImpl = pickFetch(this.deps, targetAccount.ref)
+      try {
+        const blob = await this.deps.ensureFresh(
+          provider,
+          await this.deps.loadBlob(targetAccount.ref),
+          targetAccount.ref,
+        )
+        const live = await getVendor(provider).listModels(blob, cfg, fetchImpl)
+        if (Array.isArray(live) && live.length) models = live
+      } catch { /* use built-in catalog */ }
+    }
+    if (!models) {
+      const cfg = this.deps.vendorConfig(provider)
+      models = modelCatalog(provider, cfg ? cfg.models : undefined)
+    }
     // #94: optionally hide test/preview/beta/legacy ids from the picker.
     if (typeof this.deps.hideDeprecatedModels === 'function' && this.deps.hideDeprecatedModels()) {
       models = models.filter((m) => !isDeprecatedId(String((m && m.id) || '')))
@@ -234,6 +243,11 @@ export class SubscriptionAdapter extends LlmAdapter {
               } catch { /* ignore quota capture failure */ }
             }
           } catch (err) {
+            if (err && (err.code === 'QUOTA' || err.code === 'QUOTA_EXCEEDED' || err.status === 429)) {
+              if (typeof deps.recordExhaust === 'function') deps.recordExhaust(account.ref)
+            } else if (err && (err.status === 401 || err.status === 403 || err.code === 'TOKEN_REVOKED' || err.code === 'BROKEN')) {
+              if (typeof deps.recordBroken === 'function') deps.recordBroken(account.ref)
+            }
             if (err && err.code === 'VALIDATION_REQUIRED' && err.validationUrl) {
               await deps.saveBlob(account.ref, {
                 ...blob,
@@ -271,7 +285,7 @@ export class SubscriptionAdapter extends LlmAdapter {
       }
       // #91: when the whole pool is exhausted and nothing has been streamed
       // yet, continue seamlessly on local Ollama instead of failing the chat.
-      if (!yieldedAny && typeof deps.ollamaFallback === 'function') {
+      if (!yieldedAny && !options.signal?.aborted && typeof deps.ollamaFallback === 'function') {
         yield* deps.ollamaFallback({ options, provider, err })
         return
       }

package/lib/blob.js

@@ -1,30 +1,33 @@
 function asString(value) {
-  return value == null ? '' : String(value)
+  return value == null ? "" : String(value)
 }
 
 export function serializeBlob(obj) {
-  const accessToken = asString(obj && obj.accessToken)
-  const refreshToken = asString(obj && obj.refreshToken)
-  if (!accessToken && !refreshToken) {
-    throw new Error('oauth blob needs accessToken or refreshToken')
+  if (!obj || typeof obj !== "object") throw new Error("invalid oauth blob")
+  const accessToken = asString(obj.accessToken)
+  const refreshToken = asString(obj.refreshToken)
+  if (!accessToken && !refreshToken && !obj.apiKey) {
+    throw new Error("oauth blob needs accessToken or refreshToken")
   }
   return JSON.stringify({
+    ...obj,
     accessToken,
     refreshToken,
-    expiresAt: Number(obj && obj.expiresAt) || 0,
-    label: asString(obj && obj.label),
-    email: asString(obj && obj.email),
-    accountId: asString(obj && obj.accountId),
-    projectId: asString(obj && obj.projectId),
-    ...(Array.isArray(obj && obj.usage) ? { usage: obj.usage } : {}),
-    ...((obj && obj.usageAt) ? { usageAt: Number(obj.usageAt) } : {}),
+    expiresAt: Number(obj.expiresAt) || 0,
+    label: asString(obj.label),
+    email: asString(obj.email),
+    accountId: asString(obj.accountId),
+    projectId: asString(obj.projectId),
+    ...(Array.isArray(obj.usage) ? { usage: obj.usage } : {}),
+    ...(obj.usageAt ? { usageAt: Number(obj.usageAt) } : {}),
   })
 }
 
 export function parseBlob(text) {
-  const obj = typeof text === 'string' ? JSON.parse(text) : text
-  if (!obj || typeof obj !== 'object') throw new Error('invalid oauth blob')
+  const obj = typeof text === "string" ? JSON.parse(text) : text
+  if (!obj || typeof obj !== "object") throw new Error("invalid oauth blob")
   return {
+    ...obj,
     accessToken: asString(obj.accessToken),
     refreshToken: asString(obj.refreshToken),
     expiresAt: Number(obj.expiresAt) || 0,
@@ -36,4 +39,3 @@ export function parseBlob(text) {
     ...(obj.usageAt ? { usageAt: Number(obj.usageAt) } : {}),
   }
 }
-

package/lib/cascade.js

@@ -9,6 +9,16 @@ export const DEFAULT_CASCADE_CHAINS = {
   copilot: ['cursor', 'codex'],
   cursor: ['copilot', 'claude'],
   antigravity: ['copilot', 'claude'],
+  kimi: ['qwen', 'glm', 'spark'],
+  glm: ['kimi', 'qwen', 'spark'],
+  qwen: ['kimi', 'glm', 'spark'],
+  spark: ['qwen', 'kimi', 'glm'],
+  jetbrains: ['copilot', 'cursor'],
+  perplexity: ['copilot', 'cursor'],
+  replit: ['copilot', 'cursor'],
+  cody: ['copilot', 'cursor'],
+  kiro: ['copilot', 'cursor'],
+  ernie: ['qwen', 'glm'],
 }
 
 /**

package/lib/config-schema.js

@@ -149,3 +149,55 @@ export function publicConfig(cfg) {
 
   return clone
 }
+
+export function restoreMaskedSecrets(incoming, existing) {
+  if (!incoming || typeof incoming !== "object") return incoming
+  if (!existing || typeof existing !== "object") return incoming
+
+  const out = { ...incoming }
+
+  for (const key of Object.keys(out)) {
+    if ((key.endsWith("ClientSecret") || key.endsWith("Secret")) && typeof out[key] === "string") {
+      if (out[key].includes("••••")) {
+        out[key] = existing[key] || ""
+      }
+    }
+  }
+
+  if (Array.isArray(out.slots) && Array.isArray(existing.slots)) {
+    out.slots = out.slots.map((s) => {
+      if (!s || typeof s !== "object" || typeof s.proxyUrl !== "string" || !s.proxyUrl.includes("••••")) return s
+      const match = existing.slots.find((e) => e && e.provider === s.provider && Number(e.index) === Number(s.index))
+      if (match && match.proxyUrl) {
+        return { ...s, proxyUrl: match.proxyUrl }
+      }
+      return s
+    })
+  }
+
+  if (Array.isArray(out.customVendors) && Array.isArray(existing.customVendors)) {
+    out.customVendors = out.customVendors.map((cv) => {
+      if (!cv || typeof cv !== "object") return cv
+      const match = existing.customVendors.find((e) => e && e.id === cv.id)
+      if (!match) return cv
+      const copy = { ...cv }
+      for (const f of ["apiKey", "token", "secret", "clientSecret"]) {
+        if (typeof copy[f] === "string" && copy[f].includes("••••")) {
+          copy[f] = match[f] || ""
+        }
+      }
+      if (copy.headers && typeof copy.headers === "object" && match.headers && typeof match.headers === "object") {
+        const h = { ...copy.headers }
+        for (const hk of Object.keys(h)) {
+          if (typeof h[hk] === "string" && h[hk].includes("••••")) {
+            h[hk] = match.headers[hk] || ""
+          }
+        }
+        copy.headers = h
+      }
+      return copy
+    })
+  }
+
+  return out
+}

package/lib/rotate.js

@@ -1,3 +1,4 @@
+import { computePacingRisk, calculateBurnRatePerHour } from "./forecast.js"
 import { isQuarantined } from './quarantine.js'
 import { getPinnedAccountRef, pinSession } from './session-pin.js'
 
@@ -43,7 +44,7 @@ export function cooldownBlocks(acc, family) {
 export function pickAccount(accounts, nowMs, opts) {
   const list = Array.isArray(accounts) ? accounts : []
   const now = Number(nowMs) || 0
-  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0
+  const thrRaw = opts && opts.switchAtRemaining != null ? Number(opts.switchAtRemaining) : 0.01
   const thr = Number.isFinite(thrRaw) ? thrRaw : 0
   const isVipRequest = Boolean(opts && opts.vip)
   const targetTag = opts && opts.tag
@@ -92,11 +93,20 @@ export function pickAccount(accounts, nowMs, opts) {
   // Tier 1: Quota unknown (null) & healthy
   // Tier 2: Cooldown, quarantine or exhausted
   const tiers = [[], [], []]
-  const fallback = []
 
   for (const acc of list) {
     if (!acc || !acc.hasToken) continue
 
+    if (!opts || opts.autoPacing !== false) {
+      if (acc.pacingRisk === undefined) {
+        const rem = acc.quota?.remainingPercent ?? (acc.usagePercent != null ? (100 - Number(acc.usagePercent)) : null)
+        const pace = acc.pacePerHour || (Array.isArray(acc.samples) ? calculateBurnRatePerHour(acc.samples, now) : 0)
+        const resetAt = acc.quota?.resetAt || 0
+        const riskInfo = computePacingRisk(rem, pace, resetAt, now)
+        acc.pacingRisk = riskInfo.pacingRisk
+      }
+    }
+
     // VIP Slot Reservation (#175)
     if (acc.vipOnly && !isVipRequest) continue
 
@@ -105,11 +115,16 @@ export function pickAccount(accounts, nowMs, opts) {
 
     const isCooldown = acc.cooldownUntil && Number(acc.cooldownUntil) > now && cooldownBlocks(acc, opts && opts.family)
     const inQuarantine = isQuarantined(acc, now)
-    const exhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
+    const isHardExhausted = (acc.quota && acc.quota.remaining != null && Number(acc.quota.remaining) <= 0 && acc.quota.resetAt && Number(acc.quota.resetAt) > now) ||
+                            (acc.usagePercent != null && Number(acc.usagePercent) >= 100 && (!acc.quota || !acc.quota.resetAt || Number(acc.quota.resetAt) > now))
+
+    if (isCooldown || inQuarantine || isHardExhausted) {
+      continue
+    }
 
-    if (isCooldown || inQuarantine || exhausted) {
+    const softExhausted = isQuotaExhausted(acc) || isUsageExhausted(acc)
+    if (softExhausted) {
       tiers[2].push(acc)
-      fallback.push(acc)
       continue
     }
 
@@ -140,7 +155,7 @@ export function pickAccount(accounts, nowMs, opts) {
         if (aWeight !== bWeight) return bWeight - aWeight
 
         // 3. Health Score
-        return (b.healthScore || 100) - (a.healthScore || 100)
+        return (b.healthScore ?? 100) - (a.healthScore ?? 100)
       })
 
       const chosen = tier[0]
@@ -151,7 +166,6 @@ export function pickAccount(accounts, nowMs, opts) {
     }
   }
 
-  if (fallback.length) return fallback[0]
   return null
 }
 

package/lib/routes/status.js

@@ -1,7 +1,7 @@
 // #374: Sensitive GET routes protected by same-origin check
 import { getRecentAlerts, clearAlerts } from '../alerts.js'
 import { normalizeSlots, vendorConfig } from '../accounts.js'
-import { Config, plainConfig, publicConfig } from '../config-schema.js'
+import { Config, plainConfig, publicConfig, restoreMaskedSecrets } from '../config-schema.js'
 import { isTrustedSettingsRequest, queryOf, readBody, safeJsonHandler, writeJson } from '../http.js'
 import { quotaSnapshot } from '../ratelimit.js'
 import { PROVIDERS, displayName, droppedCredentialRefs, isProvider, oauthRef } from '../refs.js'
@@ -65,7 +65,8 @@ export function registerStatusRoutes(ctx, state) {
         return
       }
       // #379: revision conflict detection (CAS)
-      const baseRev = payload?.revision != null ? Number(payload.revision) : (req.headers?.['if-match'] ? Number(req.headers['if-match']) : null)
+      const rawRev = payload?.revision ?? payload?.config?.revision ?? req.headers?.['if-match']
+      const baseRev = rawRev != null ? Number(rawRev) : null
       if (baseRev != null && !Number.isNaN(baseRev) && baseRev !== currentRevision) {
         writeJson(res, 409, {
           ok: false,
@@ -80,13 +81,16 @@ export function registerStatusRoutes(ctx, state) {
 
       if (payload && typeof payload.config === 'object') payload = payload.config
       try {
+        payload = restoreMaskedSecrets(payload, live())
         if (Array.isArray(payload.slots)) payload.slots = stripLegacySlots(payload.slots)
         const parsed = plainConfig(Config(payload))
         const dropped = droppedCredentialRefs(live().slots, parsed.slots)
         await getSettingsApi().replace(parsed)
         currentRevision++
         syncCustomVendors()
-        for (const ref of dropped) await store.clearRef(ref)
+        for (const ref of dropped) {
+          try { await store.clearRef(ref) } catch { /* best-effort cleanup */ }
+        }
         await syncAdapter()
         writeJson(res, 200, await configResponse())
       } catch (e) {

package/lib/vendors/claude.js

@@ -1,3 +1,4 @@
+import { fetchWithTimeout } from '../http.js'
 import { buildAuthorizeUrl } from '../oauth.js'
 import { anthropicPayload, modelCatalog } from '../messages.js'
 import { jsonTokenRequest, anthropicStream, httpError, tokenBlobFromOAuth, readJson } from '../wire.js'
@@ -119,15 +120,50 @@ export async function refresh(cfg, blob, fetchImpl) {
   return decorate(tokenBlobFromOAuth(json, { label: blob.label, email: blob.email }), fetchImpl)
 }
 
-export async function listModels(blob, cfg) {
-  const raw = cfg.models && cfg.models.length ? cfg.models : defaults().models
-  const entries = raw.map((entry) => {
-    const model = typeof entry === 'string' ? { id: entry, name: entry } : { ...entry }
+export async function listModels(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const rawDefault = (cfg && cfg.models && cfg.models.length) ? cfg.models : defaults().models
+  const defaultCatalog = modelCatalog(id, rawDefault.map((entry) => {
+    const model = typeof entry === "string" ? { id: entry, name: entry } : { ...entry }
     const levels = effortLevelsForModel(model.id || model.name)
     if (!levels) return model
     return { ...model, reasoning: { efforts: levels.map((level) => ({ id: level, name: level })) } }
-  })
-  return modelCatalog(id, entries)
+  }))
+
+  if (!blob || !blob.accessToken) return defaultCatalog
+
+  try {
+    const headers = {
+      "Accept": "application/json",
+      "anthropic-version": "2023-06-01",
+    }
+    if (blob.accessToken.startsWith("sk-ant-")) {
+      headers["x-api-key"] = blob.accessToken
+    } else {
+      headers["Authorization"] = `Bearer ${blob.accessToken}`
+    }
+
+    const res = await fetchWithTimeout(impl, "https://api.anthropic.com/v1/models", { headers }, { timeoutMs: 15000 })
+    if (!res.ok) return defaultCatalog
+    const json = await readJson(res)
+    const items = json && json.data
+    if (!Array.isArray(items) || !items.length) return defaultCatalog
+    const rows = []
+    for (const item of items) {
+      const modelId = item.id || item.display_name
+      if (!modelId) continue
+      const levels = effortLevelsForModel(modelId)
+      rows.push({
+        id: modelId,
+        name: item.display_name || modelId,
+        ...(levels ? { reasoning: { efforts: levels.map((level) => ({ id: level, name: level })) } } : {}),
+      })
+    }
+    if (!rows.length) return defaultCatalog
+    return modelCatalog(id, rows)
+  } catch {
+    return defaultCatalog
+  }
 }
 
 // Advertise adaptive thinking + effort only for models whose capability table

package/lib/vendors/copilot.js

@@ -1,5 +1,6 @@
 import { LlmError } from "@deepseek-ai/dsh-llm"
-import { openaiMessages, openaiTools } from "../messages.js"
+import { openaiMessages, openaiTools, modelCatalog } from "../messages.js"
+import { fetchWithTimeout } from "../http.js"
 import { openaiChatStream, readJson, httpError } from "../wire.js"
 import { asUsageSnapshot } from "../usage.js"
 
@@ -68,8 +69,50 @@ export function authorizeUrl() {
   return "https://github.com/login/device"
 }
 
-export async function listModels() {
-  return COPILOT_MODELS
+export async function listModels(blob, cfg, fetchImpl) {
+  const impl = fetchImpl || fetch
+  const fallback = modelCatalog(id, (cfg && cfg.models) || COPILOT_MODELS)
+  if (!blob) return fallback
+  const githubToken = blob.refreshToken || blob.githubToken
+  let copilotToken = blob.accessToken
+  try {
+    if ((!copilotToken || !blob.expiresAt || blob.expiresAt < Date.now() + 60000) && githubToken) {
+      const exchange = await exchangeCopilotToken(githubToken, impl)
+      if (exchange && exchange.token) {
+        copilotToken = exchange.token
+        blob.accessToken = exchange.token
+        if (exchange.expires_at) blob.expiresAt = exchange.expires_at * 1000
+      }
+    }
+    if (!copilotToken) return fallback
+    const res = await fetchWithTimeout(impl, "https://api.githubcopilot.com/models", {
+      headers: {
+        Authorization: `Bearer ${copilotToken}`,
+        Accept: "application/json",
+        "User-Agent": "GitHubCopilotChat/0.24.0",
+      },
+    }, { timeoutMs: 15000 })
+    if (!res.ok) return fallback
+    const json = await readJson(res)
+    const items = json && (json.data || json.models || json)
+    if (!Array.isArray(items) || !items.length) return fallback
+    const rows = []
+    for (const item of items) {
+      const modelId = item.id || item.name
+      if (!modelId) continue
+      if (item.capabilities && item.capabilities.type && item.capabilities.type !== "chat") continue
+      rows.push({
+        id: modelId,
+        name: item.name || modelId,
+        ...(item.capabilities && item.capabilities.limits && item.capabilities.limits.max_prompt_tokens ? { contextWindow: item.capabilities.limits.max_prompt_tokens } : {}),
+        ...(item.capabilities && item.capabilities.supports && item.capabilities.supports.vision ? { inputModalities: ["text", "image"] } : {}),
+      })
+    }
+    if (!rows.length) return fallback
+    return modelCatalog(id, rows)
+  } catch {
+    return fallback
+  }
 }
 
 export function getTelemetryHeaders(sessionId) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.6.37",
+  "version": "0.6.39",
   "description": "Use ChatGPT Codex, Claude, Grok, Antigravity, Kimi, GLM, Cursor, Kiro, Copilot, Qwen, ERNIE, Spark, JetBrains, Perplexity, Replit, and Cody subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",