ds-bot 0.0.0-stage → 0.1.0

package/src/host/models.js

@@ -0,0 +1,145 @@
+// Models. Every Bot runs on one model of its own, fixed when it is created and changed
+// only in its settings or by a Main Bot. The team's first Main Bot has none until the
+// user picks one in its chat. The Session keeps the selection durably.
+import { normalize, splitRef } from './text.js'
+
+const CATALOG_TTL_MS = 10_000
+const ROUTE_WAIT_MS = 30_000
+
+export function install(rt) {
+  const { ctx, state } = rt
+
+  let modelsSynced = null
+  let catalogCache = { at: 0, value: [] }
+  ctx.on?.('llm/adapters-updated', () => { catalogCache = { at: 0, value: [] } })
+
+  // A provider's model list can change in DSH settings without any event, so a picker
+  // that is about to be used asks for a `fresh` one.
+  async function catalog({ fresh = false } = {}) {
+    if (!fresh && Date.now() - catalogCache.at < CATALOG_TTL_MS && catalogCache.value.length > 0) return catalogCache.value
+    const entries = []
+    for (const provider of ctx.llm.listProviders()) {
+      let models = []
+      try { models = await ctx.llm.listModels(provider.id) } catch { continue }
+      for (const model of models) {
+        entries.push({
+          ref: `${provider.id}/${model.id}`,
+          provider: provider.id,
+          providerName: provider.name ?? provider.id,
+          id: model.id,
+          name: model.name ?? model.id,
+          ...(model.inputModalities ? { input: [...model.inputModalities] } : {}),
+        })
+      }
+    }
+    catalogCache = { at: Date.now(), value: entries }
+    return entries
+  }
+
+  // The profile default model of DSH as set, served or not.
+  const defaultRef = () => {
+    const selection = ctx.get?.('agentDefaultModel')?.currentSelection?.()
+    return selection?.provider && selection?.model ? `${selection.provider}/${selection.model}` : undefined
+  }
+  // The profile default model of DSH, when it is served; else the first served model.
+  function pickDefault(entries) {
+    const ref = defaultRef()
+    return entries.find(entry => entry.ref === ref)?.ref ?? entries[0]?.ref
+  }
+  const defaultModel = async () => pickDefault(await catalog())
+
+  // A full `provider/model` ref, or a model id or name that only one provider serves.
+  async function resolveModel(text) {
+    const entries = await catalog({ fresh: true })
+    const wanted = String(text ?? '').trim()
+    const exact = entries.find(entry => entry.ref === wanted)
+    if (exact) return exact.ref
+    const key = normalize(wanted)
+    const named = entries.filter(entry => normalize(entry.id) === key || normalize(entry.name) === key)
+    if (named.length === 1) return named[0].ref
+    const known = entries.map(entry => entry.ref).join(', ') || 'none'
+    throw new Error(named.length > 1
+      ? `Model ${wanted} is served by more than one provider; use one of ${named.map(entry => entry.ref).join(', ')}`
+      : `Model ${wanted} is not available. Available models: ${known}`)
+  }
+
+  // A Bot with no model yet waits for the user to pick one and changes nothing. A
+  // model that is no longer served falls back to the last one it ran on, then the default.
+  async function desiredModel(bot) {
+    if (!bot.model) return undefined
+    const entries = await catalog()
+    const served = new Set(entries.map(entry => entry.ref))
+    return [bot.model, bot.appliedModel].find(ref => ref && served.has(ref)) ?? pickDefault(entries)
+  }
+
+  // DSH's selectModel also saves the selection as the profile default model, in the
+  // background. A Bot's model is its own, so the user's default is written back after
+  // it. Selections run one at a time and wait for the write-back: profile writes land in
+  // submission order, so the next one reads the user's default, not a Bot's.
+  let selecting = Promise.resolve()
+  function selectSessionModel(sessionId, { provider, model }) {
+    const run = selecting.then(async () => {
+      const defaults = ctx.get?.('agentDefaultModel')
+      const before = defaults?.currentSelection?.()
+      const result = await ctx.sessionController.selectModel({ sessionId, provider, model })
+      if (before?.provider && before?.model && (before.provider !== provider || before.model !== model)) {
+        await defaults.saveSelection(before).catch(error => rt.warn('ds-bot: the default model was not restored: %s', error))
+      }
+      return result
+    })
+    selecting = run.catch(() => {})
+    return run
+  }
+
+  // `force` re-selects even when the record says it is applied: the composer's own
+  // model picker can move the Session without telling this plugin.
+  async function applyModel(bot, { force = false } = {}) {
+    const ref = await desiredModel(bot)
+    if (ref === undefined || (!force && bot.appliedModel === ref)) return ref
+    const route = splitRef(ref)
+    await selectSessionModel(rt.chatOf(bot.id), route)
+    for (const sessionId of rt.groupSessionsOf(bot.id)) {
+      await selectSessionModel(sessionId, route)
+        .catch(error => rt.warn('ds-bot: model for %s in a group not applied: %s', bot.name, error))
+    }
+    bot.appliedModel = ref
+    await rt.save()
+    return ref
+  }
+
+  // A provider may register after the plugin starts; a greeting waits for its Bot's
+  // model instead of failing with "no adapter registered".
+  async function waitForModel(bot, ms = ROUTE_WAIT_MS) {
+    const deadline = Date.now() + ms
+    for (;;) {
+      if (!bot.model) return undefined
+      catalogCache = { at: 0, value: [] }
+      const served = new Set((await catalog()).map(entry => entry.ref))
+      if (served.has(bot.model) || Date.now() >= deadline) return desiredModel(bot)
+      await new Promise((resolve) => {
+        const timer = setTimeout(done, Math.min(2000, deadline - Date.now()))
+        const off = ctx.on?.('llm/adapters-updated', done)
+        function done() { clearTimeout(timer); off?.(); resolve() }
+      })
+    }
+  }
+
+  // Sequential, and again whenever the served models change: a provider that
+  // registers late still gets its Bots' models selected.
+  let syncedKey
+  const syncModels = () => {
+    const key = catalogCache.value.map(entry => entry.ref).join(',')
+    if (key !== syncedKey) { syncedKey = key; modelsSynced = modelsSynced?.then(syncAll, syncAll) ?? syncAll() }
+    return modelsSynced
+  }
+  async function syncAll() {
+    for (const bot of Object.values(state.bots)) {
+      await applyModel(bot).catch(error => rt.warn('ds-bot: model for %s not applied: %s', bot.name, error))
+    }
+  }
+
+  Object.assign(rt, {
+    catalog, cachedCatalog: () => catalogCache.value, cachedDefault: () => pickDefault(catalogCache.value),
+    defaultRef, defaultModel, resolveModel, desiredModel, selectSessionModel, applyModel, waitForModel, syncModels,
+  })
+}