@tzyc/dsh-model-visibility 0.0.0-stage → 1.9.1

package/lib/capability-corrections.js

@@ -0,0 +1,65 @@
+/**
+ * Curated corrections for facts the bundled catalog gets wrong.
+ *
+ * The pi-ai / models.dev snapshot is a snapshot: vendor model names collide
+ * (`glm-5.3` is a text-only flagship while `glm-5.3-flash` is the multimodal
+ * one), and an entry can be attributed to the wrong provider family.  A wrong
+ * row that says "multimodal" is worse than an unknown one: the composer would
+ * offer image input for a model that rejects it, and the request would fail
+ * upstream.
+ *
+ * Corrections are deliberately tiny, keyed by normalized model id and labelled
+ * `official` in the UI, with the documentation URL kept for the tooltip. They
+ * only replace `catalog` / `inferred` / `unknown` evidence — an explicit
+ * provider declaration or a relay listing still wins, because that is the
+ * user's own routing configuration.
+ *
+ * Add an entry only when a primary source (the vendor's model documentation)
+ * contradicts the snapshot. Never guess from a model name here.
+ *
+ * @module lib/capability-corrections
+ */
+
+import { modelIdVariants } from './capability-catalog.js'
+
+/**
+ * Corrected facts keyed by the normalized catalog id.
+ *
+ * Shape:
+ *   `input`   — exact input modalities the vendor documents.
+ *   `code`    — dictionary key under `correction.*` for the localized note.
+ *   `note`    — English fallback when the dictionary has no key (diagnostics).
+ *   `source`  — canonical documentation URL, shown in the tooltip.
+ */
+export const CORRECTIONS = Object.freeze({
+  'glm-5.3': Object.freeze({
+    input: Object.freeze(['text']),
+    code: 'glm-5.3-text-only',
+    note: 'GLM-5.3 accepts text only; the multimodal variant is GLM-5.3-Flash / FlashX.',
+    source: 'https://docs.bigmodel.cn/cn/guide/models/text/glm-5.3',
+  }),
+})
+
+/** Normalized-id index over {@link CORRECTIONS}. */
+const INDEX = (() => {
+  const index = new Map()
+  for (const [id, correction] of Object.entries(CORRECTIONS)) {
+    for (const variant of modelIdVariants(id)) {
+      if (!index.has(variant)) index.set(variant, { id, ...correction })
+    }
+  }
+  return index
+})()
+
+/**
+ * Find the curated correction for one model id.
+ * @param value - model id as any provider spells it.
+ * @returns `{ id, input, code, note, source }` or undefined.
+ */
+export function lookupCorrection(value) {
+  for (const variant of modelIdVariants(value)) {
+    const found = INDEX.get(variant)
+    if (found !== undefined) return found
+  }
+  return undefined
+}

package/lib/image-input-gate.js

@@ -0,0 +1,113 @@
+/**
+ * Request-side image-input gate for relay adapters.
+ *
+ * The settings page can prove that a relay model accepts images (relay
+ * listing, built-in catalog, vendor correction), but the `llm-pi-ai` adapter
+ * builds an internal model object from the route configuration. For a relay
+ * that leaves `input` empty, that object falls back to the provider's
+ * `defaultInput` (`["text"]`), so both the session admission check and the
+ * adapter's own serializer reject an image that the relay really accepts.
+ *
+ * This module patches only the adapter method that materializes that model
+ * object (`modelOf`), which is used by `resolveModel`, `stream` and
+ * `imageRequestTarget` alike. The patch is read-only: it never writes settings,
+ * never changes a route, and returns the original object untouched when the
+ * capability merge says the model is text-only. It is scoped to the pi-ai
+ * adapter shape, so built-in adapters and the DeepSeek Messages adapter keep
+ * their own declarations.
+ *
+ * @module lib/image-input-gate
+ */
+
+/**
+ * True when an adapter is the pi-ai route adapter whose models come from
+ * `modelOf(snapshot, provider, model)`.
+ * @param adapter - registered adapter instance.
+ * @returns whether the adapter has the patched surface.
+ */
+function isPiAiAdapter(adapter) {
+  return (
+    adapter !== null &&
+    typeof adapter === 'object' &&
+    typeof adapter.modelOf === 'function' &&
+    typeof adapter.profileOf === 'function' &&
+    typeof adapter.current === 'function'
+  )
+}
+
+/**
+ * Patch every registered pi-ai adapter so image-capable relay models advertise
+ * `image` to the admission check and to the request serializer.
+ *
+ * @param llm - the Host `ctx.llm` service (a traceable service proxy is fine).
+ * @param options - `{ allow(provider, model), warn(error) }`.
+ * @returns `{ refresh, dispose }`; call `refresh` after adapters change.
+ */
+export function installImageInputGate(llm, options = {}) {
+  const allow = typeof options.allow === 'function' ? options.allow : () => false
+  const warn = typeof options.warn === 'function' ? options.warn : () => {}
+  /** adapter -> { original, wrapper } */
+  const patched = new Map()
+
+  const shouldAddImage = (provider, model) => {
+    try {
+      return allow(provider, model) === true
+    } catch (error) {
+      warn(error)
+      return false
+    }
+  }
+
+  const patchAdapter = (adapter) => {
+    if (!isPiAiAdapter(adapter) || patched.has(adapter)) return
+    const original = adapter.modelOf
+    const wrapper = function modelOf(snapshot, provider, model) {
+      const resolved = original.call(this, snapshot, provider, model)
+      if (resolved === null || typeof resolved !== 'object') return resolved
+      if (Array.isArray(resolved.input) && resolved.input.includes('image')) return resolved
+      if (!shouldAddImage(provider, model)) return resolved
+      const input = Array.isArray(resolved.input) ? resolved.input : ['text']
+      return { ...resolved, input: [...input, 'image'] }
+    }
+    try {
+      Object.defineProperty(adapter, 'modelOf', {
+        value: wrapper,
+        configurable: true,
+        writable: true,
+      })
+      patched.set(adapter, { original, wrapper })
+    } catch (error) {
+      warn(error)
+    }
+  }
+
+  /** Re-scan the registry; registrations are replaced on route/config changes. */
+  const refresh = () => {
+    let adapters
+    try {
+      adapters = llm?.adapters
+    } catch (_error) {
+      return
+    }
+    if (!(adapters instanceof Map)) return
+    for (const registration of adapters.values()) patchAdapter(registration?.adapter)
+  }
+
+  refresh()
+
+  return {
+    refresh,
+    dispose() {
+      for (const [adapter, record] of patched) {
+        try {
+          if (Object.getOwnPropertyDescriptor(adapter, 'modelOf')?.value === record.wrapper) {
+            delete adapter.modelOf
+          }
+        } catch (_error) {
+          // A disposed adapter simply keeps the wrapper; it no longer serves.
+        }
+      }
+      patched.clear()
+    },
+  }
+}