@goodandready/dsh-model-sync 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 GooDAnDReaDY
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @goodandready/dsh-model-sync
+
+Automatic model catalog synchronization for API-key providers in DeepSeek Harness.
+
+The plugin is designed for:
+
+- API-key providers already configured in DSH;
+- API-key providers available in the built-in DSH catalog but not configured yet;
+- future custom API-key provider routes.
+
+OAuth, subscription, and tool-only routes are intentionally outside the scope.
+
+## Status
+
+Runtime, scheduler, HTTP API, reconciliation, and Settings UI are implemented. Release and staging verification remain before publication.
+
+## Development
+
+See the project documentation under ``docs/`` for architecture, research, testing, and release notes.
+
+## API and safety
+
+`GET /dsh-model-sync/status` reports provider state without secrets.
+
+`POST /dsh-model-sync/run` defaults to a read-only dry-run:
+
+```json
+{ "provider": "openai", "dryRun": true }
+```
+
+Apply is explicit:
+
+```json
+{ "provider": "openai", "dryRun": false, "removeMissing": false }
+```

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# Bundle entry for the public DSH model synchronization plugin.
+- insert:
+    - id: dsh-model-sync
+      name: '@goodandready/dsh-model-sync'

package/lib/adapter-registry.js

@@ -0,0 +1,87 @@
+import { canUseGenericAdapter, createGenericAdapter } from './generic-adapter.js'
+import { normalizeModels } from './models.js'
+
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024
+
+const PROVIDER_ADAPTERS = Object.freeze({
+  anthropic: { endpoint: 'https://api.anthropic.com/v1/models', auth: 'x-api-key', headers: { 'anthropic-version': '2023-06-01' } },
+  google: { endpoint: 'https://generativelanguage.googleapis.com/v1beta/models', auth: 'query-key', parse: 'google' },
+  openai: { endpoint: 'https://api.openai.com/v1/models', auth: 'bearer' },
+  deepseek: { endpoint: 'https://api.deepseek.com/models', auth: 'bearer' },
+  xai: { endpoint: 'https://api.x.ai/v1/models', auth: 'bearer' },
+  openrouter: { endpoint: 'https://openrouter.ai/api/v1/models', auth: 'bearer' },
+  groq: { endpoint: 'https://api.groq.com/openai/v1/models', auth: 'bearer' },
+  mistral: { endpoint: 'https://api.mistral.ai/v1/models', auth: 'bearer' },
+  'ant-ling': { endpoint: 'https://api.ant-ling.com/v1/models', auth: 'bearer' },
+  cerebras: { endpoint: 'https://api.cerebras.ai/v1/models', auth: 'bearer' },
+  fireworks: { endpoint: 'https://api.fireworks.ai/inference/v1/models', auth: 'bearer' },
+  huggingface: { endpoint: 'https://router.huggingface.co/v1/models', auth: 'bearer' },
+  'moonshotai': { endpoint: 'https://api.moonshot.ai/v1/models', auth: 'bearer' },
+  'moonshotai-cn': { endpoint: 'https://api.moonshot.cn/v1/models', auth: 'bearer' },
+  nvidia: { endpoint: 'https://integrate.api.nvidia.com/v1/models', auth: 'bearer' },
+  'qwen-token-plan': { endpoint: 'https://token-plan.ap-southeast-1.maas.aliyuncs.com/compatible-mode/v1/models', auth: 'bearer' },
+  'qwen-token-plan-cn': { endpoint: 'https://token-plan.cn-beijing.maas.aliyuncs.com/compatible-mode/v1/models', auth: 'bearer' },
+  together: { endpoint: 'https://api.together.ai/v1/models', auth: 'bearer' },
+  'xiaomi': { endpoint: 'https://api.xiaomimimo.com/v1/models', auth: 'bearer' },
+  'xiaomi-token-plan-ams': { endpoint: 'https://token-plan-ams.xiaomimimo.com/v1/models', auth: 'bearer' },
+  'xiaomi-token-plan-cn': { endpoint: 'https://token-plan-cn.xiaomimimo.com/v1/models', auth: 'bearer' },
+  'xiaomi-token-plan-sgp': { endpoint: 'https://token-plan-sgp.xiaomimimo.com/v1/models', auth: 'bearer' },
+  zai: { endpoint: 'https://api.z.ai/api/coding/paas/v4/models', auth: 'bearer' },
+  'zai-coding-cn': { endpoint: 'https://open.bigmodel.cn/api/coding/paas/v4/models', auth: 'bearer' },
+})
+
+function parseRows(provider, payload, parser) {
+  if (parser === 'google') {
+    const rows = Array.isArray(payload?.models) ? payload.models : []
+    return normalizeModels(provider, rows.map((row) => ({
+      ...row,
+      id: String(row.name ?? '').replace(/^models\//, ''),
+      name: row.displayName ?? row.display_name ?? row.name,
+      contextWindow: row.inputTokenLimit,
+      maxTokens: row.outputTokenLimit,
+    })))
+  }
+  const rows = payload?.data ?? payload?.models ?? payload?.availableModels
+  return normalizeModels(provider, Array.isArray(rows) ? rows : [])
+}
+
+async function fetchSpecific(profile, descriptor, { resolveCredential, fetchImpl, signal }) {
+  const apiKey = profile.apiKeyEnv ? await resolveCredential(profile.apiKeyEnv) : ''
+  const url = new URL(profile.baseURL ? `${String(profile.baseURL).replace(/\/+$/, '')}/models` : descriptor.endpoint)
+  const headers = { Accept: 'application/json', ...(descriptor.headers ?? {}) }
+  if (descriptor.auth === 'bearer' && apiKey) headers.Authorization = `Bearer ${apiKey}`
+  if (descriptor.auth === 'x-api-key' && apiKey) headers['x-api-key'] = apiKey
+  if (descriptor.auth === 'query-key' && apiKey) url.searchParams.set('key', apiKey)
+  const response = await fetchImpl(url, { headers, signal })
+  if (!response.ok) throw new Error(`model catalog request failed with HTTP ${response.status}`)
+  const text = await response.text()
+  if (Buffer.byteLength(text, 'utf8') > MAX_RESPONSE_BYTES) throw new Error('model catalog response is too large')
+  let payload
+  try {
+    payload = JSON.parse(text)
+  } catch {
+    throw new Error('model catalog response is not valid JSON')
+  }
+  return parseRows(profile.provider, payload, descriptor.parse)
+}
+
+export function createProviderAdapterRegistry({ resolveCredential, fetchImpl = fetch } = {}) {
+  const generic = createGenericAdapter({ resolveCredential, fetchImpl })
+  return Object.freeze({
+    descriptors: PROVIDER_ADAPTERS,
+    select(profile) {
+      if (canUseGenericAdapter(profile)) return generic
+      const descriptor = PROVIDER_ADAPTERS[profile?.provider]
+      if (!descriptor) return null
+      return Object.freeze({
+        id: `provider:${profile.provider}`,
+        canHandle: () => true,
+        discover: (current, options = {}) => fetchSpecific(current, descriptor, {
+          resolveCredential,
+          fetchImpl,
+          ...options,
+        }),
+      })
+    },
+  })
+}

package/lib/client.js

@@ -0,0 +1,35 @@
+window.__ModuleLoader__.load({
+  id: '@goodandready/dsh-model-sync',
+  factory: (require) => {
+    var module = { exports: {} }
+    var exports = module.exports
+    const React = require('react')
+    const en = {
+      title: 'Model synchronization', desc: 'Refresh model catalogs for API-key providers. A dry-run is the default; applying changes is explicit.', loading: 'Loading…', refresh: 'Refresh status', run: 'Discover', apply: 'Apply changes', dryRun: 'Preview only (dry-run)', all: 'All API-key providers', ok: 'ready', dormant: 'not configured', running: 'running…', noProviders: 'No API-key providers found.', lastRun: 'Last run',
+    }
+    const ru = {
+      title: 'Синхронизация моделей', desc: 'Обновляет каталоги моделей у провайдеров с API-ключом. По умолчанию только dry-run; применение запускается явно.', loading: 'Загрузка…', refresh: 'Обновить статус', run: 'Проверить', apply: 'Применить изменения', dryRun: 'Только просмотр (dry-run)', all: 'Все API-key провайдеры', ok: 'готов', dormant: 'не настроен', running: 'выполняется…', noProviders: 'API-key провайдеры не найдены.', lastRun: 'Последний запуск',
+    }
+    const API = '/dsh-model-sync'
+    function useLocale(ctx) {
+      return React.useSyncExternalStore(React.useMemo(() => (cb) => ctx.locale?.subscribe?.(cb) ?? (() => {}), [ctx]), React.useCallback(() => ctx.locale?.getSnapshot?.().active ?? 'en', [ctx]))
+    }
+    function ModelSyncSection({ ctx }) {
+      const locale = useLocale(ctx); const t = locale === 'ru' ? ru : en
+      const [status, setStatus] = React.useState(null); const [provider, setProvider] = React.useState(''); const [dryRun, setDryRun] = React.useState(true); const [busy, setBusy] = React.useState(false); const [error, setError] = React.useState('')
+      const load = React.useCallback(() => { setError(''); return fetch(`${API}/status`).then((r) => r.json()).then(setStatus).catch((e) => setError(String(e?.message ?? e))) }, [])
+      React.useEffect(() => { load(); const timer = setInterval(load, 15000); return () => clearInterval(timer) }, [load])
+      const run = () => { setBusy(true); setError(''); fetch(`${API}/run`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ provider: provider || undefined, dryRun }) }).then(async (r) => { const body = await r.json(); if (!r.ok) throw new Error(body?.error?.message ?? `HTTP ${r.status}`); return body }).then(setStatus).catch((e) => setError(String(e?.message ?? e))).finally(() => setBusy(false)) }
+      const rows = status?.providers ?? []; const button = (label, onClick) => React.createElement('button', { type: 'button', disabled: busy, onClick, style: { marginRight: 8 } }, label)
+      return React.createElement('div', { style: { display: 'flex', flexDirection: 'column', gap: 10, maxWidth: 680 } },
+        React.createElement('p', null, t.desc),
+        React.createElement('div', null, React.createElement('select', { value: provider, onChange: (e) => setProvider(e.target.value) }, React.createElement('option', { value: '' }, t.all), rows.map((row) => React.createElement('option', { key: row.provider, value: row.provider }, row.provider))), React.createElement('label', { style: { marginLeft: 12 } }, React.createElement('input', { type: 'checkbox', checked: dryRun, onChange: (e) => setDryRun(e.target.checked) }), ` ${t.dryRun}`)),
+        React.createElement('div', null, button(t.refresh, load), button(dryRun ? t.run : t.apply, run)),
+        status?.lastRun ? React.createElement('small', null, `${t.lastRun}: ${new Date(status.lastRun.finishedAt).toLocaleString()}`) : null, status?.running || busy ? React.createElement('small', null, t.running) : null, error ? React.createElement('small', { style: { color: 'var(--dsw-alias-state-error-primary)' } }, error) : null, status === null ? React.createElement('small', null, t.loading) : null, rows.length === 0 && status ? React.createElement('small', null, t.noProviders) : null,
+        rows.map((row) => React.createElement('div', { key: row.provider }, `${row.provider}: ${row.configured ? t.ok : t.dormant} · ${row.models?.length ?? 0} models`)),
+      )
+    }
+    function apply(ctx) { ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dsh-model-sync', order: 25, label: () => 'Model Sync' }, (props) => React.createElement(ModelSyncSection, { ...props, ctx }))) }
+    module.exports = { apply, inject: ['slots', 'locale'] }; return module.exports
+  },
+})

package/lib/credentials.js

@@ -0,0 +1,21 @@
+const PRINTABLE_API_KEY = /^[\x21-\x7E]+$/
+
+export function normalizeApiKey(value) {
+  if (value === undefined || value === null) return ''
+  const key = String(value).trim()
+  if (!key) return ''
+  if (!PRINTABLE_API_KEY.test(key)) {
+    throw new Error('API key contains characters that cannot be sent in an HTTP header')
+  }
+  return key
+}
+
+export function createCredentialResolver(ctx) {
+  const credentials = ctx?.get?.('credentials') ?? ctx?.credentials
+  return async (ref) => {
+    if (!ref) return ''
+    if (!credentials?.resolve) throw new Error('DSH credentials service is unavailable')
+    const result = await credentials.resolve(ref)
+    return normalizeApiKey(typeof result === 'string' ? result : result?.value)
+  }
+}

package/lib/generic-adapter.js

@@ -0,0 +1,67 @@
+import { normalizeModels } from './models.js'
+
+const MAX_RESPONSE_BYTES = 4 * 1024 * 1024
+const SUPPORTED_APIS = new Set(['openai-completions', 'openai-responses'])
+
+function endpointFor(baseURL) {
+  const base = String(baseURL ?? '').trim().replace(/\/+$/, '')
+  if (!base) throw new Error('missing baseURL')
+  return base.endsWith('/models') ? base : `${base}/models`
+}
+
+async function readBody(response) {
+  const declared = Number(response.headers?.get?.('content-length') ?? NaN)
+  if (Number.isFinite(declared) && declared > MAX_RESPONSE_BYTES) {
+    throw new Error('model catalog response is too large')
+  }
+  const text = await response.text()
+  if (Buffer.byteLength(text, 'utf8') > MAX_RESPONSE_BYTES) {
+    throw new Error('model catalog response is too large')
+  }
+  return text
+}
+
+function rowsFrom(payload) {
+  const rows = payload?.data ?? payload?.models ?? payload?.availableModels
+  return Array.isArray(rows) ? rows : []
+}
+
+export function canUseGenericAdapter(profile) {
+  return Boolean(profile?.baseURL) && SUPPORTED_APIS.has(profile?.api || 'openai-completions')
+}
+
+export async function discoverOpenAIModels(profile, {
+  resolveCredential,
+  fetchImpl = fetch,
+  signal,
+} = {}) {
+  if (!canUseGenericAdapter(profile)) {
+    throw new Error('generic discovery requires an OpenAI-compatible baseURL and protocol')
+  }
+  const apiKey = profile.apiKeyEnv ? await resolveCredential(profile.apiKeyEnv) : ''
+  const headers = { Accept: 'application/json' }
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`
+  const response = await fetchImpl(endpointFor(profile.baseURL), { headers, signal })
+  if (!response.ok) throw new Error(`model catalog request failed with HTTP ${response.status}`)
+  let payload
+  try {
+    payload = JSON.parse(await readBody(response))
+  } catch {
+    throw new Error('model catalog response is not valid JSON')
+  }
+  return normalizeModels(profile.provider ?? '', rowsFrom(payload))
+}
+
+export function createGenericAdapter({ resolveCredential, fetchImpl = fetch } = {}) {
+  return Object.freeze({
+    id: 'openai-compatible',
+    canHandle: canUseGenericAdapter,
+    discover(profile, options = {}) {
+      return discoverOpenAIModels(profile, {
+        resolveCredential,
+        fetchImpl,
+        ...options,
+      })
+    },
+  })
+}

package/lib/http.js

@@ -0,0 +1,64 @@
+const BASE = '/dsh-model-sync'
+
+function json(res, status, body) {
+  res.writeHead(status, { 'content-type': 'application/json; charset=utf-8' })
+  res.end(JSON.stringify(body))
+}
+
+function trusted(req) {
+  if (req.headers?.['sec-fetch-site'] === 'cross-site') return false
+  const origin = req.headers?.origin
+  if (!origin) return true
+  const host = req.headers?.host
+  if (!host) return false
+  try { return new URL(origin).host === host } catch { return false }
+}
+
+function readJson(req) {
+  return new Promise((resolve, reject) => {
+    let raw = ''
+    req.on('data', (chunk) => {
+      raw += chunk
+      if (raw.length > 64 * 1024) reject(new Error('request body is too large'))
+    })
+    req.on('end', () => {
+      try { resolve(JSON.parse(raw || '{}')) } catch (error) { reject(error) }
+    })
+    req.on('error', reject)
+  })
+}
+
+export function normalizeRunRequest(body) {
+  if (body === null || typeof body !== 'object' || Array.isArray(body)) throw new Error('request body must be an object')
+  if (body.provider !== undefined && (typeof body.provider !== 'string' || body.provider.length > 128)) throw new Error('provider must be a short string')
+  if (body.dryRun !== undefined && typeof body.dryRun !== 'boolean') throw new Error('dryRun must be boolean')
+  if (body.removeMissing !== undefined && typeof body.removeMissing !== 'boolean') throw new Error('removeMissing must be boolean')
+  return {
+    ...(body.provider ? { provider: body.provider } : {}),
+    dryRun: body.dryRun !== false,
+    removeMissing: body.removeMissing === true,
+  }
+}
+
+export function registerHttpApi(ctx, synchronizer) {
+  const makeHandler = (route) => async (req, res) => {
+    if (!trusted(req)) return json(res, 403, { error: { code: 'forbidden', message: 'dsh-model-sync: cross-origin request rejected' } })
+    if (route === 'status') {
+      if (req.method !== 'GET') return json(res, 405, { error: { code: 'method', message: 'GET only' } })
+      return json(res, 200, { ...synchronizer.status(), providers: synchronizer.listProviders() })
+    }
+    if (req.method !== 'POST') return json(res, 405, { error: { code: 'method', message: 'POST only' } })
+    let options
+    try { options = normalizeRunRequest(await readJson(req)) }
+    catch (error) { return json(res, 400, { error: { code: 'bad-request', message: error instanceof Error ? error.message : String(error) } }) }
+    try { const result = await synchronizer.run(options); return json(res, 200, { ...result, providers: synchronizer.listProviders() }) }
+    catch (error) {
+      const code = error?.code === 'SETTINGS_CONFLICT' ? 409 : error?.code === 'SETTINGS_UNAVAILABLE' ? 503 : 500
+      return json(res, code, { error: { code: error?.code ?? 'run-failed', message: error instanceof Error ? error.message : String(error) } })
+    }
+  }
+  return [
+    ctx.webServer.register({ kind: 'exact', path: `${BASE}/status`, handler: makeHandler('status') }),
+    ctx.webServer.register({ kind: 'exact', path: `${BASE}/run`, handler: makeHandler('run') }),
+  ]
+}

package/lib/index.js

@@ -0,0 +1,53 @@
+import Schema from '@deepseek-ai/schemastery'
+import { createProviderService } from './provider-service.js'
+import { createModelSynchronizer } from './synchronizer.js'
+import { createSyncScheduler } from './scheduler.js'
+import { registerHttpApi } from './http.js'
+
+export const name = '@goodandready/dsh-model-sync'
+export const inject = ['llm', 'settings', 'webServer', 'credentials']
+
+const NS = 'dsh-model-sync'
+
+export const Config = Schema.object({
+  enabled: Schema.boolean().default(true),
+  intervalMinutes: Schema.number().default(60),
+  autoApply: Schema.boolean().default(false),
+  providers: Schema.array(Schema.object({
+    provider: Schema.string().required(),
+    enabled: Schema.boolean().default(true),
+  })).default([]),
+})
+
+export function apply(ctx, config) {
+  let liveConfig = Config(structuredClone(config || {}))
+  let reconfigure = () => {}
+  const settings = ctx.get('settings')
+  if (settings?.settings?.register) {
+    const scope = settings.settings.register(NS, Config, { base: config })
+    liveConfig = Config(scope.get() || config)
+    ctx.effect(() => scope.onChange((next) => {
+      liveConfig = Config(next || config)
+      reconfigure()
+    }), 'dsh-model-sync: settings')
+  }
+
+  const service = createProviderService(ctx)
+  const synchronizer = createModelSynchronizer(ctx, { getConfig: () => liveConfig })
+  const scheduler = createSyncScheduler(synchronizer, { getConfig: () => liveConfig })
+  reconfigure = () => scheduler.reconfigure()
+  scheduler.start()
+  ctx.effect(() => {
+    const registrations = registerHttpApi(ctx, synchronizer)
+  ctx.effect(() => () => scheduler.stop(), 'dsh-model-sync: scheduler cleanup')
+    return () => {
+      for (const dispose of registrations) if (typeof dispose === 'function') dispose()
+    }
+  }, 'dsh-model-sync: http api')
+  ctx.effect(() => {
+    if (!liveConfig.enabled) return () => {}
+    ctx.provide('modelSync', service)
+    ctx.provide('modelSyncRunner', synchronizer)
+    return () => {}
+  }, 'dsh-model-sync: service')
+}

package/lib/inventory.js

@@ -0,0 +1,84 @@
+import { normalizeModels } from './models.js'
+
+export const API_KEY_PROVIDER_IDS = Object.freeze([
+  'anthropic',
+  'ant-ling',
+  'azure-openai-responses',
+  'cerebras',
+  'cloudflare-ai-gateway',
+  'cloudflare-workers-ai',
+  'deepseek',
+  'fireworks',
+  'google',
+  'groq',
+  'huggingface',
+  'kimi-coding',
+  'minimax',
+  'minimax-cn',
+  'mistral',
+  'moonshotai',
+  'moonshotai-cn',
+  'nvidia',
+  'openai',
+  'opencode',
+  'opencode-go',
+  'openrouter',
+  'qwen-token-plan',
+  'qwen-token-plan-cn',
+  'radius',
+  'together',
+  'vercel-ai-gateway',
+  'xai',
+  'xiaomi',
+  'xiaomi-token-plan-ams',
+  'xiaomi-token-plan-cn',
+  'xiaomi-token-plan-sgp',
+  'zai',
+  'zai-coding-cn',
+])
+
+const API_KEY_PROVIDER_SET = new Set(API_KEY_PROVIDER_IDS)
+
+function settingsProfiles(settings) {
+  try {
+    return settings?.get('llm-pi-ai')?.providers ?? {}
+  } catch {
+    return {}
+  }
+}
+
+function liveProviders(llm) {
+  return new Map((llm?.listProviders?.() ?? []).map((row) => [row.id, row]))
+}
+
+export function isApiKeyProvider(entry, profile) {
+  if (profile?.apiKeyEnv) return true
+  return entry?.declared === false && API_KEY_PROVIDER_SET.has(entry.provider)
+}
+
+export function listApiKeyProviders(llm, settings) {
+  const profiles = settingsProfiles(settings)
+  const live = liveProviders(llm)
+  const directory = llm?.listConfigurableProviders?.() ?? []
+  const out = []
+  const seen = new Set()
+  for (const entry of directory) {
+    const profile = profiles[entry.provider] ?? {}
+    if (!isApiKeyProvider(entry, profile) || seen.has(entry.provider)) continue
+    seen.add(entry.provider)
+    out.push({
+      provider: entry.provider,
+      displayName: entry.displayName ?? entry.provider,
+      settingsNs: entry.settingsNs,
+      settingsPath: [...(entry.settingsPath ?? [])],
+      declared: entry.declared === true,
+      configured: Object.prototype.hasOwnProperty.call(profiles, entry.provider),
+      live: live.has(entry.provider),
+      apiKeyEnv: profile.apiKeyEnv ?? '',
+      baseURL: profile.baseURL ?? '',
+      api: profile.api ?? '',
+      models: normalizeModels(entry.provider, profile.models ?? []),
+    })
+  }
+  return out
+}

package/lib/models.js

@@ -0,0 +1,62 @@
+const FIELD_ALIASES = Object.freeze({
+  contextWindow: ['contextWindow', 'context_window', 'contextLength', 'context_length'],
+  maxTokens: ['maxTokens', 'max_tokens', 'max_output_tokens', 'maxOutputTokens'],
+})
+
+function firstNumber(row, fields) {
+  for (const field of fields) {
+    const value = Number(row?.[field])
+    if (Number.isFinite(value) && value > 0) return value
+  }
+  return undefined
+}
+
+export function normalizeModel(provider, row) {
+  if (typeof row === 'string') {
+    row = { id: row }
+  }
+  if (!row || typeof row !== 'object') return null
+  const id = String(row.id ?? row.slug ?? row.model ?? '').trim()
+  if (!id) return null
+  const name = String(row.name ?? row.displayName ?? row.display_name ?? id).trim() || id
+  const contextWindow = firstNumber(row, FIELD_ALIASES.contextWindow)
+  const maxTokens = firstNumber(row, FIELD_ALIASES.maxTokens)
+  return {
+    provider,
+    id,
+    name,
+    ...(contextWindow === undefined ? {} : { contextWindow }),
+    ...(maxTokens === undefined ? {} : { maxTokens }),
+    ...(row.description ? { description: String(row.description) } : {}),
+  }
+}
+
+export function normalizeModels(provider, rows) {
+  const out = []
+  const seen = new Set()
+  for (const row of rows ?? []) {
+    const model = normalizeModel(provider, row)
+    if (!model || seen.has(model.id)) continue
+    seen.add(model.id)
+    out.push(model)
+  }
+  return out
+}
+
+export function diffModels(previous, next) {
+  const before = new Map(normalizeModels('', previous).map((row) => [row.id, row]))
+  const after = new Map(normalizeModels('', next).map((row) => [row.id, row]))
+  const added = []
+  const removed = []
+  const changed = []
+  for (const [id, model] of after) {
+    if (!before.has(id)) added.push(model)
+    else if (JSON.stringify(before.get(id)) !== JSON.stringify(model)) {
+      changed.push({ before: before.get(id), after: model })
+    }
+  }
+  for (const [id, model] of before) {
+    if (!after.has(id)) removed.push(model)
+  }
+  return { added, removed, changed, hasChanges: added.length > 0 || removed.length > 0 || changed.length > 0 }
+}

package/lib/provider-service.js

@@ -0,0 +1,20 @@
+import { listApiKeyProviders } from './inventory.js'
+
+export function createProviderService(ctx) {
+  const readSettings = () => {
+    try {
+      return ctx.get('settings')
+    } catch {
+      return undefined
+    }
+  }
+
+  const listProviders = () => listApiKeyProviders(ctx.llm, readSettings())
+
+  return Object.freeze({
+    listProviders,
+    getProvider(provider) {
+      return listProviders().find((row) => row.provider === provider) ?? null
+    },
+  })
+}

package/lib/reconcile.js

@@ -0,0 +1,50 @@
+import { diffModels, normalizeModels } from './models.js'
+
+function sameModel(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right)
+}
+
+export function reconcileModels(provider, current, discovered, {
+  removeMissing = false,
+} = {}) {
+  const before = normalizeModels(provider, current)
+  const advertised = normalizeModels(provider, discovered)
+  const advertisedById = new Map(advertised.map((row) => [row.id, row]))
+  const next = []
+  const stale = []
+  for (const row of before) {
+    const fresh = advertisedById.get(row.id)
+    if (fresh) next.push(fresh)
+    else {
+      stale.push(row)
+      if (!removeMissing) next.push(row)
+    }
+  }
+  const known = new Set(before.map((row) => row.id))
+  for (const row of advertised) {
+    if (!known.has(row.id)) next.push(row)
+  }
+  const diff = diffModels(before, next)
+  return {
+    provider,
+    before,
+    advertised,
+    next,
+    stale,
+    diff,
+    changed: diff.hasChanges,
+    unchangedAdvertised: advertised.length === before.length && advertised.every((row, index) => sameModel(row, before[index])),
+  }
+}
+
+export function catalogPatch(section, provider, nextModels) {
+  const current = section && typeof section === 'object' ? section : {}
+  const providers = current.providers && typeof current.providers === 'object'
+    ? structuredClone(current.providers)
+    : {}
+  const profile = providers[provider] && typeof providers[provider] === 'object'
+    ? providers[provider]
+    : {}
+  providers[provider] = { ...profile, models: structuredClone(nextModels) }
+  return { ...structuredClone(current), providers }
+}

package/lib/scheduler.js

@@ -0,0 +1,37 @@
+export function createSyncScheduler(sync, { getConfig = () => ({}), setIntervalFn = setInterval, clearIntervalFn = clearInterval, logger = console } = {}) {
+  let timer = null
+  let running = false
+
+  function stop() {
+    if (timer !== null) clearIntervalFn(timer)
+    timer = null
+    running = false
+  }
+
+  function start() {
+    stop()
+    const config = getConfig() ?? {}
+    const minutes = Number(config.intervalMinutes)
+    if (config.enabled === false || !Number.isFinite(minutes) || minutes <= 0) return false
+    const period = Math.max(1, minutes) * 60_000
+    timer = setIntervalFn(async () => {
+      if (running) return
+      running = true
+      try {
+        await sync.run({ dryRun: config.autoApply !== true })
+      } catch (error) {
+        logger.warn?.(`[dsh-model-sync] scheduled run failed: ${error instanceof Error ? error.message : String(error)}`)
+      } finally {
+        running = false
+      }
+    }, period)
+    return true
+  }
+
+  return Object.freeze({
+    start,
+    stop,
+    reconfigure: start,
+    status: () => ({ active: timer !== null, running }),
+  })
+}

package/lib/synchronizer.js

@@ -0,0 +1,103 @@
+import { listApiKeyProviders } from './inventory.js'
+import { createProviderAdapterRegistry } from './adapter-registry.js'
+import { createCredentialResolver } from './credentials.js'
+import { reconcileModels, catalogPatch } from './reconcile.js'
+
+const PIAI_NS = 'llm-pi-ai'
+
+function settingsOf(ctx) {
+  try { return ctx.get('settings') } catch { return undefined }
+}
+
+function descriptorOf(settings, ns) {
+  try { return settings?.describe?.({ redactSecrets: true })?.find((row) => row.ns === ns) }
+  catch { return undefined }
+}
+
+function profileOf(settings, provider) {
+  try { return settings?.get(PIAI_NS)?.providers?.[provider] ?? {} }
+  catch { return {} }
+}
+
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+export function createModelSynchronizer(ctx, { getConfig = () => ({}), fetchImpl = fetch } = {}) {
+  const resolveCredential = createCredentialResolver(ctx)
+  const registry = createProviderAdapterRegistry({ resolveCredential, fetchImpl })
+  let running = null
+  let lastRun = null
+
+  function providers() {
+    return listApiKeyProviders(ctx.llm, settingsOf(ctx))
+  }
+
+  async function discover(row, { signal } = {}) {
+    const settings = settingsOf(ctx)
+    const profile = { ...profileOf(settings, row.provider), provider: row.provider }
+    const adapter = registry.select(profile)
+    if (!adapter) return { provider: row.provider, status: 'unsupported', models: [], message: 'no supported API-key model adapter' }
+    if (!profile.apiKeyEnv && !profile.baseURL) {
+      return { provider: row.provider, status: 'dormant', models: [], message: 'provider has no API key route configured' }
+    }
+    try {
+      const models = await adapter.discover(profile, { signal })
+      return { provider: row.provider, status: 'ok', models }
+    } catch (error) {
+      return { provider: row.provider, status: 'error', models: [], message: errorMessage(error) }
+    }
+  }
+
+  async function run(options = {}) {
+    if (running) return running
+    const config = getConfig() ?? {}
+    const dryRun = options.dryRun !== false
+    const removeMissing = options.removeMissing === true
+    const selected = typeof options.provider === 'string' && options.provider
+      ? providers().filter((row) => row.provider === options.provider)
+      : providers().filter((row) => config.providers?.length === 0 || config.providers?.some((item) => item.provider === row.provider && item.enabled !== false))
+    const startedAt = Date.now()
+    const task = (async () => {
+      const results = []
+      for (const row of selected) {
+        const discovered = await discover(row, options)
+        if (discovered.status !== 'ok') {
+          results.push({ ...discovered, changed: false })
+          continue
+        }
+        const settings = settingsOf(ctx)
+        const current = profileOf(settings, row.provider).models ?? row.models
+        const reconciliation = reconcileModels(row.provider, current, discovered.models, { removeMissing })
+        results.push({ ...discovered, ...reconciliation, changed: reconciliation.changed })
+      }
+      const result = { startedAt, finishedAt: Date.now(), dryRun, removeMissing, results, applied: false }
+      if (!dryRun && results.some((row) => row.status === 'ok' && row.changed)) {
+        const settings = settingsOf(ctx)
+        const section = settings?.get?.(PIAI_NS)
+        const descriptor = descriptorOf(settings, PIAI_NS)
+        if (!section || !descriptor || typeof settings.replace !== 'function') {
+          throw Object.assign(new Error('llm-pi-ai settings are not writable'), { code: 'SETTINGS_UNAVAILABLE' })
+        }
+        const next = structuredClone(section)
+        for (const row of results) {
+          if (row.status === 'ok' && row.changed) next.providers = catalogPatch(next, row.provider, row.next).providers
+        }
+        await settings.replace(PIAI_NS, next, descriptor.revision)
+        result.applied = true
+      }
+      lastRun = result
+      return result
+    })()
+    running = task.finally(() => { running = null })
+    return running
+  }
+
+  return Object.freeze({
+    listProviders: providers,
+    getProvider: (provider) => providers().find((row) => row.provider === provider) ?? null,
+    discover,
+    run,
+    status: () => ({ running: Boolean(running), lastRun }),
+  })
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@goodandready/dsh-model-sync",
+  "version": "0.1.0",
+  "description": "Automatic model catalog synchronization for API-key DeepSeek Harness providers.",
+  "keywords": ["deepseek-harness", "dsh", "dsh-plugin", "models", "api-key", "catalog"],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GooDAnDReaDY/dsh-model-sync.git"
+  },
+  "homepage": "https://github.com/GooDAnDReaDY/dsh-model-sync",
+  "bugs": {
+    "url": "https://github.com/GooDAnDReaDY/dsh-model-sync/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./cordis.patch.yml": "./cordis.patch.yml"
+  },
+  "files": ["lib", "cordis.patch.yml", "README.md", "LICENSE"],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-slots"
+      ]
+    }
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "license": "MIT",
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.6"
+  }
+}