@goodandready/dsh-model-sync 0.2.1 → 0.2.3

package/lib/index.js

@@ -23,25 +23,37 @@ export const Config = Schema.object({
 export function apply(ctx, config) {
   let liveConfig = Config(structuredClone(config || {}))
   let reconfigure = () => {}
-  let saveConfig = async () => {
-    throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+  let saveConfigImpl
+  // ctx.inject starts a child fiber; keep a stable function reference for the
+  // synchronizer while that fiber connects to the Settings service.
+  const saveConfig = async (patch) => {
+    if (!saveConfigImpl) {
+      throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+    }
+    return saveConfigImpl(patch)
   }
-  const settings = ctx.get('settings')
-  if (settings?.settings?.register) {
-    const scope = settings.settings.register(NS, Config, { base: config })
+
+  // The settings capability is injected as sctx.settings; ctx.get('settings')
+  // returns the provider service and does not expose the register API.
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(NS, Config, { base: config })
     liveConfig = Config(scope.get() || config)
-    const watch = scope.watch ?? scope.onChange
-    ctx.effect(() => watch?.call(scope, (next) => {
+    const stop = scope.watch((next) => {
       liveConfig = Config(next || config)
       reconfigure()
-    }), 'dsh-model-sync: settings')
-    saveConfig = async (patch) => {
-      if (typeof scope.update === 'function') return scope.update(patch)
-      const next = { ...scope.get(), ...patch }
-      if (typeof scope.replace === 'function') return scope.replace(next)
-      throw Object.assign(new Error('dsh-model-sync settings are not writable'), { code: 'CONFIG_UNAVAILABLE' })
+    })
+    saveConfigImpl = async (patch) => {
+      const result = await scope.update(patch)
+      // Settings watchers are serialized asynchronously; refresh the snapshot
+      // synchronously as well so a following request sees the new allowlist.
+      liveConfig = Config(scope.get() || config)
+      return result
     }
-  }
+    sctx.effect(() => () => {
+      saveConfigImpl = undefined
+      stop()
+    }, 'dsh-model-sync: settings')
+  })
 
   const service = createProviderService(ctx)
   const synchronizer = createModelSynchronizer(ctx, { getConfig: () => liveConfig, saveConfig })

package/lib/synchronizer.js

@@ -149,9 +149,22 @@ export function createModelSynchronizer(ctx, { getConfig = () => ({}), saveConfi
       ? selectedModels.map((id) => availableById.get(id))
       : (available.length > 0 ? available : current)
     const next = catalogPatch(section, provider, nextModels)
-    await settings.replace(PIAI_NS, next, descriptor.revision)
-    const modelSelections = { ...(config.modelSelections ?? {}), [provider]: selectedModels }
+    const previousModelSelections = structuredClone(config.modelSelections ?? {})
+    const modelSelections = { ...previousModelSelections, [provider]: selectedModels }
+
+    // Persist the allowlist first. If the LLM catalog write fails, roll the
+    // allowlist back so the two namespaces cannot be left disagreeing.
     await saveConfig({ modelSelections })
+    try {
+      await settings.replace(PIAI_NS, next, descriptor.revision)
+    } catch (error) {
+      try {
+        await saveConfig({ modelSelections: previousModelSelections })
+      } catch {
+        // Preserve the original, more actionable catalog-write error.
+      }
+      throw error
+    }
     return { provider, selectedModels, models: nextModels, availableModels: available, applied: true }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-model-sync",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Automatic model catalog synchronization for API-key DeepSeek Harness providers.",
   "keywords": [
     "deepseek-harness",