@huai_xin/dsh-workbuddy 0.1.18 → 0.1.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@huai_xin/dsh-workbuddy",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "description": "WorkBuddy model provider for DeepSeek Harness (international + China deployments)",
   "type": "module",
   "main": "./src/index.js",

package/src/catalog-cache.js

@@ -78,15 +78,20 @@ function readFile(path) {
     if (typeof parsed.savedAt !== 'number' || !Number.isFinite(parsed.savedAt)) return undefined
     return {
       // Volatile fields are dropped on read too: a snapshot written before they
-      // were excluded must not leak a stale rate either. The admission policy
-      // is applied as well — the cache appends, so an id excluded later has to
-      // be filtered when reading. Because `credits` is never cached, the policy
-      // reduces to "whitelisted" for cached entries, which is exactly the part
-      // of the list that does not depend on a live rate.
+      // were excluded must not leak a stale rate either. The admission policy is
+      // applied as well — the cache appends, so an id excluded later has to be
+      // filtered when reading.
+      //
+      // It is the *structural* half of the policy, not `keepModel`: that one also
+      // demands a live credits rate, and rates are never cached. Applying it here
+      // filtered out every entry a `/v3/config` read had produced, so the fallback
+      // only worked for ids the account-scoped payload had touched too. What a cached
+      // entry proves is that the deployment lists it — which is exactly what the cache
+      // is for.
       entries: parsed.entries
         .filter((entry) => isCatalogModelId(entry?.id))
         .map((entry) => Object.fromEntries(Object.entries(entry).filter(([key]) => !VOLATILE_FIELDS.has(key))))
-        .filter(keepModel),
+        .filter((entry) => entry.preset !== true),
       source: typeof parsed.source === 'string' ? parsed.source : 'unknown',
       savedAt: parsed.savedAt,
       /** How many models the read behind this snapshot actually returned. */

package/src/catalog.js

@@ -294,6 +294,14 @@ export function withConsistentEfforts(entry, candidates = []) {
  * fields the primary source left empty are taken, so scoped stays authoritative
  * for what it does declare.
  */
+/** The first argument that is a non-empty string, or undefined. */
+function firstNonEmpty(...values) {
+  for (const value of values) {
+    if (typeof value === 'string' && value.trim().length > 0) return value
+  }
+  return undefined
+}
+
 export function mergeEntries(entries, extra) {
   if (extra.length === 0) return entries
   const byId = new Map(extra.map((entry) => [entry.id, entry]))
@@ -304,6 +312,11 @@ export function mergeEntries(entries, extra) {
       .sort(byEffortOrder)
     const merged = {
       ...entry,
+      // A name is required by the harness (`listModels` rejects the whole provider with
+      // INVALID_CATALOG on an empty one), and the two sources disagree on which models
+      // carry one. Take the non-empty side, and fall back to the id so a sparse record
+      // can never blank out a catalog.
+      name: firstNonEmpty(entry.name, other.name, entry.id),
       ...(entry.descriptionZh === undefined && other.descriptionZh !== undefined ? { descriptionZh: other.descriptionZh } : {}),
       ...(entry.descriptionEn === undefined && other.descriptionEn !== undefined ? { descriptionEn: other.descriptionEn } : {}),
       ...(entry.credits === undefined && other.credits !== undefined ? { credits: other.credits } : {}),