@tzyc/dsh-model-visibility 1.9.1 → 1.10.1

package/index.js

@@ -27,7 +27,11 @@ import path from 'node:path'
 import z from '@deepseek-ai/schemastery'
 
 import { createModelInfoService } from './lib/model-info.js'
+import { createLearnedCatalog } from './lib/learned-catalog.js'
 import { createOverrideStore } from './lib/model-overrides.js'
+import { createCapabilityVerifier } from './lib/check-catalog.js'
+import { toModelListCsv, toUsageCsv } from './lib/export-csv.js'
+import { createUsageLedger } from './lib/usage-ledger.js'
 import { createProviderProbe, readProviderProfiles } from './lib/provider-probe.js'
 import { stripWrittenFields, writeCapabilities } from './lib/provider-write.js'
 import { installImageInputGate } from './lib/image-input-gate.js'
@@ -111,6 +115,16 @@ export function apply(ctx, config) {
   // needs a synchronous read. See `lib/model-overrides.js`.
   const overrides = createOverrideStore({ logger })
 
+  // The learned capability snapshot replaces the abandoned static catalog:
+  // the online verification run seeds it, and every same-named model served
+  // later resolves against the cached rows. See `lib/learned-catalog.js`.
+  // Tests may inject a store through the inject scope (`scope.get('learned')`).
+  let learned = null
+  const learnedFor = () => {
+    if (learned !== null) return learned
+    learned = createLearnedCatalog({ logger })
+    return learned
+  }
   /** Current hidden keys, read through the stable volatile reference. */
   const liveList = () => {
     const value = config?.[FIELD]
@@ -237,15 +251,20 @@ export function apply(ctx, config) {
       fallbackProfiles = null
     }
 
+    const learnedService =
+      (typeof scope.get === 'function' ? scope.get('learned') : undefined) ?? learnedFor()
+
     const service = createModelInfoService(scope.llm, {
       enrichment: probe === null ? undefined : ({ fresh }) => probe.read({ fresh }),
       overrides,
+      learned: learnedService,
       // Synchronous evidence for the request-side image gate: provider profiles
       // from the settings document plus the last completed relay probe.
       context: () => ({
         profiles: probe === null ? profilesForGate() : probe.profiles(),
         discovered: probe?.peek()?.discovered,
         overrides,
+        learned: learnedService,
       }),
     })
 
@@ -264,6 +283,36 @@ export function apply(ctx, config) {
     })
     scope.effect(() => () => imageInput.dispose(), 'model-visibility: image input gate')
 
+    // Token-usage ledger behind the page's stats strip: session logs are read
+    // incrementally in a background pass, the check sweep records its own
+    // spend into the same buckets.
+    const usageLedger = createUsageLedger({ logger })
+    let lastRescanAt = -Infinity
+    const nowMs = () => Date.now()
+    const maybeRescan = () => {
+      if (usageLedger.isScanning()) return
+      if (nowMs() - lastRescanAt < 60_000) return
+      lastRescanAt = nowMs()
+      usageLedger.rescan().catch(() => {})
+    }
+
+    // The online capability verifier: the user's chosen checker model plus
+    // two public catalogs fill the learned snapshot and (optionally) write
+    // back into the provider settings documents.
+    const verifier = createCapabilityVerifier({
+      llm: scope.llm,
+      settings,
+      learned: learnedService,
+      ledger: usageLedger,
+      logger,
+      onApplied: () => {
+        clearFallbackProfiles()
+        probe?.noteSettingsChanged()
+        service.invalidate()
+        imageInput.refresh()
+      },
+    })
+
     /** Answer with JSON; the route is diagnostics-friendly on purpose. */
     const json = (value, status = 200) =>
       new Response(JSON.stringify(value), {
@@ -300,6 +349,7 @@ export function apply(ctx, config) {
               probe?.invalidate()
               clearFallbackProfiles()
               overrides.invalidate()
+              learnedService.invalidate()
               imageInput.refresh()
             }
             try {
@@ -434,6 +484,134 @@ export function apply(ctx, config) {
       'model-visibility: override route',
     )
 
+    // Token-usage read for the page's stats strip; the background scan runs
+    // whenever the ledger could have grown and the page asks for a read.
+    scope.effect(
+      () =>
+        connection.fetch.register({
+          path: `${API}/usage`,
+          methods: ['GET', 'POST'],
+          requestBody: 'buffered',
+          async fetch(request) {
+            if (String(request.method || 'GET').toUpperCase() === 'POST') {
+              lastRescanAt = -Infinity
+            }
+            maybeRescan()
+            try {
+              return json({ ok: true, value: usageLedger.read() })
+            } catch (error) {
+              return json(
+                {
+                  ok: false,
+                  error: {
+                    code: 'usage/failed',
+                    message: error instanceof Error ? error.message : String(error),
+                  },
+                },
+                500,
+              )
+            }
+          },
+        }),
+      'model-visibility: usage route',
+    )
+
+    // One-click exports: the token ledger and the visible-model capability
+    // list, both as CSV downloads through the same-origin route.
+    scope.effect(
+      () =>
+        connection.fetch.register({
+          path: `${API}/export`,
+          methods: ['GET'],
+          requestBody: 'buffered',
+          async fetch(request) {
+            const params = new URL(request.url).searchParams
+            const which = params.get('type') === 'models' ? 'models' : 'usage'
+            let body
+            let name
+            try {
+              if (which === 'usage') {
+                body = toUsageCsv(usageLedger.read())
+                name = `model-visibility-usage-${new Date().toISOString().slice(0, 10)}.csv`
+              } else {
+                const catalog = await service.read()
+                body = toModelListCsv(catalog, { hidden: liveList() })
+                name = `model-visibility-models-${new Date().toISOString().slice(0, 10)}.csv`
+              }
+            } catch (error) {
+              return json(
+                {
+                  ok: false,
+                  error: {
+                    code: 'export/failed',
+                    message: error instanceof Error ? error.message : String(error),
+                  },
+                },
+                500,
+              )
+            }
+            return new Response(body, {
+              status: 200,
+              headers: {
+                'Content-Type': 'text/csv; charset=utf-8',
+                'Content-Disposition': `attachment; filename="${name}"`,
+                'Cache-Control': 'no-store',
+              },
+            })
+          },
+        }),
+      'model-visibility: export route',
+    )
+
+    // The verify sweep: state reads are instant, a start posts and the Host
+    // runs batches in the background without holding the HTTP call open.
+    scope.effect(
+      () =>
+        connection.fetch.register({
+          path: `${API}/verify`,
+          methods: ['GET', 'POST'],
+          requestBody: 'buffered',
+          async fetch(request) {
+            const method = String(request.method || 'GET').toUpperCase()
+            if (method === 'GET') {
+              return json({ ok: true, value: { state: verifier.snapshot(), learned: learnedService.meta() } })
+            }
+            let body
+            try {
+              body = await request.json()
+            } catch (_error) {
+              body = {}
+            }
+            if (body !== null && typeof body === 'object' && body.cancel === true) {
+              verifier.cancel()
+              return json({ ok: true, value: { state: verifier.snapshot() } })
+            }
+            const provider = typeof body?.provider === 'string' ? body.provider : undefined
+            const model = typeof body?.model === 'string' ? body.model : undefined
+            if (provider === undefined || model === undefined) {
+              return json(
+                { ok: false, error: { code: 'verify/params', message: 'provider and model are required' } },
+                400,
+              )
+            }
+            // The sweep runs in the background: the response only reports that
+            // it was accepted, and polling GET observes the progress state.
+            if (!verifier.isRunning()) {
+              verifier
+                .start({ checker: { provider, model }, writeBack: body?.writeBack !== false })
+                .then(() => {
+                  // Learned facts (and possibly provider settings) changed.
+                  service.invalidate()
+                  imageInput.refresh()
+                })
+                .catch(() => {})
+            }
+            return json({ ok: true, value: { state: verifier.snapshot(), accepted: true } })
+          },
+        }),
+      'model-visibility: verify route',
+    )
+
     // A route/credential change invalidates both the capability cache and (when
     // it actually changed routing facts) the relay-probe cache. Ordinary
     // settings writes — hiding one model — only invalidate the capability

package/lib/capability-catalog.js

@@ -1,14 +1,12 @@
 /**
- * Catalog matching and family heuristics.
+ * Model-kind matching and family heuristics.
  *
  * The adapter contract only carries `inputModalities`, and for a custom relay
  * that field is usually the provider's `defaultInput` (text) rather than a fact
- * about the model. This module fills that gap from two places, in order:
- *
- * 1. the pi-ai / models.dev snapshot in `model-catalog.js` (exact id match
- *    after normalizing aggregator prefixes and request suffixes),
- * 2. conservative name rules for model families whose capabilities are common
- *    knowledge (Claude, GPT-4o+, Gemini, Grok 4+, VL/vision variants).
+ * about the model. When neither the adapter nor a verified learned fact knows
+ * better, this module answers from conservative name rules for model families
+ * whose capabilities are common knowledge (Claude, GPT-4o+, Gemini, Grok 4+,
+ * VL/vision variants).
  *
  * Everything returned here is *inferred*: callers must label it as such so the
  * page never presents a guess as an adapter declaration.
@@ -16,10 +14,6 @@
  * @module lib/capability-catalog
  */
 
-import { CATALOG_GENERATED_AT, CATALOG_PI_AI_VERSION, MODEL_CATALOG } from './model-catalog.js'
-
-export { CATALOG_GENERATED_AT, CATALOG_PI_AI_VERSION, MODEL_CATALOG }
-
 /** Kinds the page knows how to label. */
 export const MODEL_KINDS = Object.freeze([
   'chat',
@@ -42,64 +36,6 @@ const TRANSLATION_WORDS = /(^|[-_./\s])(translate|translation|translator)([-_./\
 
 const VISION_WORDS = /(^|[-_./\s])(vl|vision|visual|omni|multimodal|mm)([-_./\s]|$)|llava|pixtral|internvl|molmo|idefics|qwen[\d.]*-?vl|glm-[\d.]+v|kimi-.*-vl/
 
-/** Strip aggregator namespaces, request suffixes and resolution variants. */
-export function normalizeModelId(value) {
-  let id = String(value ?? '').trim().toLowerCase()
-  if (id === '') return ''
-  id = id.replace(/^~/, '')
-  // Providers may stack request variants (for example `:free:thinking`).
-  // Strip them one at a time so aliases remain stable without broad folding.
-  let previous
-  do {
-    previous = id
-    id = id.replace(/:(batch|free|extended|thinking|online|nitro)$/, '')
-    id = id.replace(/-(free|batch)$/, '')
-  } while (id !== previous)
-  const slash = id.lastIndexOf('/')
-  if (slash !== -1) id = id.slice(slash + 1)
-  id = id.replace(/^(global|us|eu|apac|jp|au|ca)\./, '')
-  id = id.replace(/^(anthropic|openai|google|xai|x-ai|meta|mistralai|moonshotai|minimax|nvidia|qwen|z-ai|zai|deepseek|bytedance-seed)\./, '')
-  return id
-}
-
-/** Lookup keys for one model id, most specific first. */
-export function modelIdVariants(value) {
-  const base = normalizeModelId(value)
-  if (base === '') return []
-  const variants = [base]
-  const withoutResolution = base.replace(/-(4k|2k|8k|hd|uhd)$/, '')
-  if (withoutResolution !== base) variants.push(withoutResolution)
-  const withoutSuffix = withoutResolution.replace(/-(latest|preview|new)$/, '')
-  if (!variants.includes(withoutSuffix)) variants.push(withoutSuffix)
-  const compact = base.replace(/[^a-z0-9]+/g, '')
-  if (compact !== '' && !variants.includes(compact)) variants.push(compact)
-  return variants
-}
-
-/** Exact/alias index over the generated snapshot. */
-const INDEX = (() => {
-  const index = new Map()
-  for (const [id, entry] of Object.entries(MODEL_CATALOG)) {
-    for (const variant of modelIdVariants(id)) {
-      if (!index.has(variant)) index.set(variant, { id, ...entry })
-    }
-  }
-  return index
-})()
-
-/**
- * Find the snapshot entry for one model id.
- * @param value - model id as any provider spells it.
- * @returns `{ id, type, input?, output?, reasoning?, contextWindow?, maxTokens?, provider? }` or undefined.
- */
-export function lookupCatalogModel(value) {
-  for (const variant of modelIdVariants(value)) {
-    const found = INDEX.get(variant)
-    if (found !== undefined) return found
-  }
-  return undefined
-}
-
 /** Coarse kind from the id/name alone. */
 export function inferModelKind(id, name = '') {
   const text = `${String(id ?? '')} ${String(name ?? '')}`.toLowerCase()

package/lib/capability-corrections.js

@@ -20,7 +20,7 @@
  * @module lib/capability-corrections
  */
 
-import { modelIdVariants } from './capability-catalog.js'
+import { modelIdVariants } from './model-id.js'
 
 /**
  * Corrected facts keyed by the normalized catalog id.