@goodandready/dsh-moa 0.2.4 → 0.2.6

package/README.md

@@ -37,7 +37,7 @@ Single-model AI generation often suffers from blind spots, single-perspective bi
 4. **Instant Live Canvas Previewing**: When web applications or UI components are generated, `dsh-moa` integrates seamlessly with `@goodandready/dsh-live-canvas`, automatically spawning sandboxes for 1-click browser previewing.
 5. **Token-Saving Chat Summarization**: Replaces massive code dumps in chat bubbles with compact file listings and clean architectural summaries.
 6. **One-Shot Session Model Restoration**: Executes cleanly as a one-shot turn modifier, automatically reverting back to the user's primary session model immediately after completion.
-7. **Inherent Cost Tracking & Token Estimation**: Embedded pricing calculator for frontier models estimating token usage and run costs directly in the summary badge without external dependencies.
+7. **Dynamic Model Pricing Catalog & Token Estimation**: Real-time rate resolution for 300+ models fetched automatically in the background from OpenRouter's public catalog (cached locally in `~/.dsh/storages/dsh-moa-catalog.json` for 24h), plus support for direct vendor rates and custom `prices` overrides in `settings.yaml`.
 8. **Refinement Mode (Incremental Edits)**: Automatically detects existing codebase context to generate precise delta modifications instead of destructive full-file rewrites.
 9. **Fast Mode & Custom Judge Criteria**: Ultra-fast single-model preset for quick tasks and customizable evaluation guidelines for the judge.
 10. **Run History & Win-Rate Leaderboard**: Persistent logging with built-in REST endpoints (`/dsh-moa/history` and `/dsh-moa/leaderboard`).
@@ -156,6 +156,13 @@ dsh-moa:
       aggregator:
         provider: "your-reasoning-provider"
         model: "your-judge-model"
+  prices:
+    "my-provider/my-model":
+      input: 0.20
+      output: 0.80
+    "ollama/*":
+      input: 0
+      output: 0
     code-review:
       references:
         - provider: "your-fast-provider"

package/docs/README.ru.md

@@ -37,7 +37,7 @@
 4. **Мгновенный предпросмотр через Live Canvas**: При создании веб-приложений и UI-компонентов `dsh-moa` бесшовно интегрируется с `@goodandready/dsh-live-canvas`, автоматически инициализируя контейнер для предпросмотра в браузере в 1 клик.
 5. **Экономия токенов в чате**: Вместо вывода огромных листингов кода в чат формируется компактный отчет с перечнем созданных файлов и архитектурным резюме.
 6. **Одноразовый модификатор сессии**: Команда выполняется в рамках одного такта и автоматически возвращает исходную модель сессии пользователя сразу после завершения.
-7. **Встроенный подсчет стоимости и токенов**: Собственный калькулятор стоимости моделей оценивает расход токенов и цену запуска напрямую в бейдже без внешних плагинов.
+7. **Динамический каталог тарифов и подсчет токенов**: Актуальные цены на 300+ моделей автоматически подтягиваются из публичного каталога OpenRouter (без ключей и авторизации), кешируются в `~/.dsh/storages/dsh-moa-catalog.json` на 24 часа, а также поддерживают прямые вендорские тарифы и пользовательские оверрайды `prices` в `settings.yaml`.
 8. **Режим доработки (Refinement Mode)**: Автоматически считывает контекст существующего проекта и генерирует точечные дельта-правки без перетирания всей кодовой базы.
 9. **Быстрый режим (Fast Mode) и критерии судьи**: Режим для одиночных быстрых задач без судьи и гибкая настройка фокуса оценки (безопасность, производительность, минимализм).
 10. **История запусков и лидерборд моделей**: Персистентное логирование запусков и REST-эндпоинты (`/dsh-moa/history` и `/dsh-moa/leaderboard`).
@@ -156,6 +156,13 @@ dsh-moa:
       aggregator:
         provider: "your-reasoning-provider"
         model: "your-judge-model"
+  prices:
+    "my-provider/my-model":
+      input: 0.20
+      output: 0.80
+    "ollama/*":
+      input: 0
+      output: 0
     code-review:
       references:
         - provider: "your-fast-provider"

package/lib/client.js

@@ -379,6 +379,10 @@ window.__ModuleLoader__.load({
         updateCurrentPreset((p) => ({ ...p, reference_temperature: val }))
       }
 
+      const setJudgeCriteria = (criteria) => {
+        updateCurrentPreset((p) => ({ ...p, judge_criteria: criteria }))
+      }
+
       const setReferenceModel = (idx, prov, mod) => {
         updateCurrentPreset((p) => {
           const refs = [...(p.reference_models || [])]
@@ -469,6 +473,7 @@ window.__ModuleLoader__.load({
       const currentRefs = currentPreset.reference_models || []
       const aggTemp = currentPreset.aggregator_temperature ?? 0.4
       const refTemp = currentPreset.reference_temperature ?? 0.6
+      const judgeCriteria = currentPreset.judge_criteria || ''
 
       return React.createElement(
         React.Fragment,
@@ -769,16 +774,159 @@ window.__ModuleLoader__.load({
       )
     }
 
+    let rootCtx = null
+
+    const en = {
+        title: 'Mixture of Agents (MoA)',
+        description: 'Run tasks with multiple parallel proposer models and a synthesizing judge model',
+        slashMoa: 'Run task through Mixture of Agents (/moa <prompt>)',
+        defaultPreset: 'Default Preset (used on /moa without arguments)',
+        isDefault: 'default',
+        presetSelectLabel: 'Active Preset to Configure:',
+        createNewPreset: 'Create new preset...',
+        makeDefault: 'Make Default',
+        makeDefaultHint: 'Use this preset for /moa when no preset argument is given',
+        deletePreset: 'Delete preset',
+        delete: 'Delete',
+        confirmDeletePreset: 'Are you sure you want to delete preset',
+        newPresetPlaceholder: 'New preset name (e.g. fast-audit)',
+        create: 'Create',
+        cancel: 'Cancel',
+        aggregatorTitle: 'Judge / Aggregator Model (who reviews and synthesizes)',
+        aggregatorDesc: 'Evaluates candidate proposals, corrects hallucinations, and outputs the final unified solution.',
+        temperature: 'Temperature',
+        aggTempHint: 'Recommended 0.2 - 0.4 for rigorous verification and factual synthesis.',
+        proposersTitle: 'Candidate Models (Advisors)',
+        proposersDesc: 'Generates independent candidate answers in parallel to provide diverse perspectives.',
+        refTempLabel: 'Candidates Temperature (solution diversity):',
+        refTempHint: 'Recommended 0.6 - 0.8 for diverse creative hypotheses.',
+        parallelCount: 'Parallel workers',
+        candidate: 'Candidate',
+        addCandidate: 'Add parallel model slot',
+        remove: 'Remove',
+        save: 'Save Changes',
+        saved: 'Saved successfully',
+        loading: 'Saving…',
+        retry: 'Retry connection',
+        unavailable: 'MoA service temporarily unavailable (reconnecting...)',
+        searchPlaceholder: 'Search by model name or provider...',
+        modelsFound: 'Found',
+        of: 'of',
+        clear: 'Clear',
+        noModelsMatch: 'No models found matching query.',
+        useCustom: 'Use custom',
+        selectModel: 'Select model...',
+        judgeCriteriaLabel: 'Custom Judge Evaluation Criteria (optional):',
+        judgeCriteriaPlaceholder: 'e.g. Priority: performance, zero external dependencies, robust edge-case handling...',
+      }
+
+    const ru = {
+        title: 'Mixture of Agents (MoA)',
+        description: 'Запуск задач через ансамбль параллельных моделей-советников и модель-судью',
+        slashMoa: 'Запустить задачу через архитектуру Mixture of Agents (/moa <prompt>)',
+        defaultPreset: 'Основной пресет (при вызове /moa без параметров)',
+        isDefault: 'основной',
+        presetSelectLabel: 'Текущий пресет для настройки:',
+        createNewPreset: 'Создать новый пресет...',
+        makeDefault: 'Сделать основным',
+        makeDefaultHint: 'Использовать этот пресет для /moa при вызове без параметров',
+        deletePreset: 'Удалить пресет',
+        delete: 'Удалить',
+        confirmDeletePreset: 'Вы уверены, что хотите удалить пресет',
+        newPresetPlaceholder: 'Название нового пресета (например: fast-audit)',
+        create: 'Создать',
+        cancel: 'Отмена',
+        aggregatorTitle: 'Ведущая модель / Судья (кто проверяет и объединяет)',
+        aggregatorDesc: 'Сопоставляет варианты кандидатов, устраняет ошибки и синтезирует итоговое решение.',
+        temperature: 'Температура',
+        aggTempHint: 'Рекомендуется 0.2 – 0.4 для строгой проверки и синтеза без выдумок.',
+        proposersTitle: 'Модели-кандидаты (советники)',
+        proposersDesc: 'Параллельно формируют независимые варианты решения одной задачи.',
+        refTempLabel: 'Температура кандидатов (разнообразие решений):',
+        refTempHint: 'Рекомендуется 0.6 – 0.8 для получения независимых и креативных вариантов.',
+        parallelCount: 'Параллельных моделей',
+        candidate: 'Кандидат',
+        addCandidate: 'Добавить модель в параллель',
+        remove: 'Удалить',
+        save: 'Сохранить',
+        saved: 'Успешно сохранено',
+        loading: 'Сохранение…',
+        retry: 'Повторить подключение',
+        unavailable: 'Служба MoA временно недоступна (переподключение...)',
+        searchPlaceholder: 'Поиск модели по названию или провайдеру...',
+        modelsFound: 'Найдено',
+        of: 'из',
+        clear: 'Сбросить',
+        noModelsMatch: 'Модели не найдены.',
+        useCustom: 'Использовать кастомное',
+        selectModel: 'Выберите модель...',
+        judgeCriteriaLabel: 'Критерии оценки судьи (опционально):',
+        judgeCriteriaPlaceholder: 'например: Приоритет — производительность, минимум зависимостей, обработка граничных случаев...',
+      }
+
+    function makeT(ctx, props) {
+      return (key) => {
+        if (props && typeof props.t === 'function') {
+          try {
+            const res = props.t(key)
+            if (res && res !== key) return res
+          } catch (_) {}
+        }
+        const effectiveCtx = (props && props.ctx) || ctx || rootCtx
+        if (effectiveCtx && effectiveCtx.locale && typeof effectiveCtx.locale.bind === 'function') {
+          try {
+            const bound = effectiveCtx.locale.bind(NS)
+            const res = bound(key)
+            if (res && res !== key) return res
+          } catch (_) {}
+        }
+        const curLocale = (effectiveCtx && effectiveCtx.locale && effectiveCtx.locale.getSnapshot && effectiveCtx.locale.getSnapshot().active) || 'ru'
+        const dict = curLocale === 'en' ? en : ru
+        return dict[key] || ru[key] || en[key] || key
+      }
+    }
+
     function useMoASettings(props) {
-      const t = props.t || ((k) => k)
+      const t = makeT(rootCtx, props)
+      const effectiveCtx = (props && props.ctx) || rootCtx
+
+      // Reactive binding to settingsScope if available
+      const scope = React.useMemo(() => {
+        if (!effectiveCtx) return undefined
+        const s = effectiveCtx.get ? effectiveCtx.get('settingsScope') : effectiveCtx.settingsScope
+        return s && typeof s.bind === 'function' ? s.bind({ namespace: NS }) : undefined
+      }, [effectiveCtx])
+
+      const snapshot = React.useSyncExternalStore
+        ? React.useSyncExternalStore(
+            React.useMemo(() => (cb) => (scope ? scope.subscribe(cb) : () => {}), [scope]),
+            React.useCallback(() => (scope ? scope.getSnapshot() : { status: 'ready' }), [scope]),
+            React.useCallback(() => ({ status: 'loading' }), [])
+          )
+        : null
+
       const [status, setStatus] = React.useState('loading')
       const [presets, setPresets] = React.useState([])
       const [defaultPreset, setDefaultPreset] = React.useState('default')
       const [availableModels, setAvailableModels] = React.useState([])
       const [saveStatus, setSaveStatus] = React.useState('')
 
+      // Sync from settingsScope snapshot when available
+      React.useEffect(() => {
+        if (!scope || !snapshot) return
+        const snapStatus = snapshot.status || 'ready'
+        if (snapStatus === 'ready') {
+          const val = snapshot.value || {}
+          if (Array.isArray(val.presets)) setPresets(val.presets)
+          if (val.default_preset) setDefaultPreset(val.default_preset)
+          setStatus('ready')
+        } else if (snapStatus === 'unavailable') {
+          setStatus('unavailable')
+        }
+      }, [scope, snapshot])
+
       const reload = React.useCallback(() => {
-        setStatus('loading')
+        if (!scope) setStatus('loading')
 
         fetch('/dsh-moa/presets', { cache: 'no-store' })
           .then((r) => {
@@ -790,13 +938,13 @@ window.__ModuleLoader__.load({
               setPresets(data.presets || [])
               setDefaultPreset(data.defaultPreset || 'default')
               setStatus('ready')
-            } else {
+            } else if (!scope) {
               setStatus('unavailable')
             }
           })
           .catch((err) => {
             console.warn('[dsh-moa] Presets fetch failed:', err)
-            setStatus('unavailable')
+            if (!scope) setStatus('unavailable')
           })
 
         fetch('/dsh-moa/models', { cache: 'no-store' })
@@ -809,7 +957,7 @@ window.__ModuleLoader__.load({
           .catch((err) => {
             console.warn('[dsh-moa] Models fetch failed:', err)
           })
-      }, [])
+      }, [scope])
 
       React.useEffect(() => {
         reload()
@@ -817,6 +965,27 @@ window.__ModuleLoader__.load({
 
       const handleSave = () => {
         setSaveStatus(t('loading'))
+
+        if (scope && typeof scope.set === 'function') {
+          Promise.all([
+            scope.set('presets', presets),
+            scope.set('default_preset', defaultPreset),
+          ])
+            .then(() => {
+              setSaveStatus(t('saved'))
+              setTimeout(() => setSaveStatus(''), 2500)
+            })
+            .catch((err) => {
+              console.warn('[dsh-moa] scope.set failed, trying REST fallback:', err)
+              doRestSave()
+            })
+          return
+        }
+
+        doRestSave()
+      }
+
+      const doRestSave = () => {
         fetch('/dsh-moa/presets', {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
@@ -883,6 +1052,64 @@ window.__ModuleLoader__.load({
       )
     }
 
+
+    // ── ERROR BOUNDARY ──────────────────────────────────────────────
+    class MoAErrorBoundary extends React.Component {
+      constructor(props) {
+        super(props)
+        this.state = { hasError: false, error: null, errorInfo: null }
+      }
+      static getDerivedStateFromError(error) {
+        return { hasError: true, error }
+      }
+      componentDidCatch(error, errorInfo) {
+        console.error('[dsh-moa] MoAErrorBoundary caught error:', error, errorInfo)
+        this.setState({ errorInfo })
+      }
+      render() {
+        if (this.state.hasError) {
+          return React.createElement(
+            'div',
+            {
+              style: {
+                padding: '16px',
+                borderRadius: '8px',
+                border: '1px solid #ef4444',
+                background: 'rgba(239,68,68,0.08)',
+                color: '#ef4444',
+                fontSize: '13px',
+                fontFamily: 'monospace',
+                whiteSpace: 'pre-wrap',
+                wordBreak: 'break-word',
+              },
+            },
+            React.createElement('div', { style: { fontWeight: 700, marginBottom: 8 } }, '⚠ MoA Settings Error'),
+            React.createElement('div', null, String(this.state.error)),
+            this.state.errorInfo && React.createElement(
+              'details',
+              { style: { marginTop: 8 } },
+              React.createElement('summary', null, 'Component stack'),
+              React.createElement('pre', { style: { fontSize: 11 } }, this.state.errorInfo.componentStack || '')
+            ),
+            React.createElement(
+              'button',
+              {
+                type: 'button',
+                style: {
+                  marginTop: 12, padding: '6px 16px', border: '1px solid #ef4444',
+                  background: 'transparent', color: '#ef4444', borderRadius: 6,
+                  cursor: 'pointer', fontSize: 12,
+                },
+                onClick: () => this.setState({ hasError: false, error: null, errorInfo: null }),
+              },
+              'Retry'
+            )
+          )
+        }
+        return this.props.children
+      }
+    }
+
     function MoACard(props) {
       ensureStyles()
       const state = useMoASettings(props)
@@ -936,142 +1163,41 @@ window.__ModuleLoader__.load({
       )
     }
 
-    exports.inject = ['slots', 'locale', 'inputTriggers']
+    exports.inject = ['slots', 'locale', 'inputTriggers', 'settingsScope']
     exports.apply = function apply(ctx) {
-      const registerLocale = () => {
-        if (localeRegistered) return
+      rootCtx = ctx
+      const t = makeT(ctx)
+      const addLocale = (locale, dictionary) => {
         try {
           if (ctx.locale && typeof ctx.locale.register === 'function') {
-            localeRegistered = true
-            return ctx.locale.register(NS, {
-        en: {
-          title: 'Mixture of Agents (MoA)',
-          description: 'Run tasks with multiple parallel proposer models and a synthesizing judge model',
-          slashMoa: 'Run task through Mixture of Agents (/moa <prompt>)',
-          defaultPreset: 'Default Preset (used on /moa without arguments)',
-          isDefault: 'default',
-          presetSelectLabel: 'Active Preset to Configure:',
-          createNewPreset: 'Create new preset...',
-          makeDefault: 'Make Default',
-          makeDefaultHint: 'Use this preset for /moa when no preset argument is given',
-          deletePreset: 'Delete preset',
-          delete: 'Delete',
-          confirmDeletePreset: 'Are you sure you want to delete preset',
-          newPresetPlaceholder: 'New preset name (e.g. fast-audit)',
-          create: 'Create',
-          cancel: 'Cancel',
-          aggregatorTitle: 'Judge / Aggregator Model (who reviews and synthesizes)',
-          aggregatorDesc: 'Evaluates candidate proposals, corrects hallucinations, and outputs the final unified solution.',
-          temperature: 'Temperature',
-          aggTempHint: 'Recommended 0.2 - 0.4 for rigorous verification and factual synthesis.',
-          proposersTitle: 'Candidate Models (Advisors)',
-          proposersDesc: 'Generates independent candidate answers in parallel to provide diverse perspectives.',
-          refTempLabel: 'Candidates Temperature (solution diversity):',
-          refTempHint: 'Recommended 0.6 - 0.8 for diverse creative hypotheses.',
-          parallelCount: 'Parallel workers',
-          candidate: 'Candidate',
-          addCandidate: 'Add parallel model slot',
-          remove: 'Remove',
-          save: 'Save Changes',
-          saved: 'Saved successfully',
-          loading: 'Saving…',
-          retry: 'Retry connection',
-          unavailable: 'MoA service temporarily unavailable (reconnecting...)',
-          searchPlaceholder: 'Search by model name or provider...',
-          modelsFound: 'Found',
-          of: 'of',
-          clear: 'Clear',
-          noModelsMatch: 'No models found matching query.',
-          useCustom: 'Use custom',
-          selectModel: 'Select model...',
-          judgeCriteriaLabel: 'Custom Judge Evaluation Criteria (optional):',
-          judgeCriteriaPlaceholder: 'e.g. Priority: performance, zero external dependencies, robust edge-case handling...',
-        },
-        ru: {
-          title: 'Mixture of Agents (MoA)',
-          description: 'Запуск задач через ансамбль параллельных моделей-советников и модель-судью',
-          slashMoa: 'Запустить задачу через архитектуру Mixture of Agents (/moa <prompt>)',
-          defaultPreset: 'Основной пресет (при вызове /moa без параметров)',
-          isDefault: 'основной',
-          presetSelectLabel: 'Текущий пресет для настройки:',
-          createNewPreset: 'Создать новый пресет...',
-          makeDefault: 'Сделать основным',
-          makeDefaultHint: 'Использовать этот пресет для /moa при вызове без параметров',
-          deletePreset: 'Удалить пресет',
-          delete: 'Удалить',
-          confirmDeletePreset: 'Вы уверены, что хотите удалить пресет',
-          newPresetPlaceholder: 'Название нового пресета (например: fast-audit)',
-          create: 'Создать',
-          cancel: 'Отмена',
-          aggregatorTitle: 'Ведущая модель / Судья (кто проверяет и объединяет)',
-          aggregatorDesc: 'Сопоставляет варианты кандидатов, устраняет ошибки и синтезирует итоговое решение.',
-          temperature: 'Температура',
-          aggTempHint: 'Рекомендуется 0.2 – 0.4 для строгой проверки и синтеза без выдумок.',
-          proposersTitle: 'Модели-кандидаты (советники)',
-          proposersDesc: 'Параллельно формируют независимые варианты решения одной задачи.',
-          refTempLabel: 'Температура кандидатов (разнообразие решений):',
-          refTempHint: 'Рекомендуется 0.6 – 0.8 для получения независимых и креативных вариантов.',
-          parallelCount: 'Параллельных моделей',
-          candidate: 'Кандидат',
-          addCandidate: 'Добавить модель в параллель',
-          remove: 'Удалить',
-          save: 'Сохранить',
-          saved: 'Успешно сохранено',
-          loading: 'Сохранение…',
-          retry: 'Повторить подключение',
-          unavailable: 'Служба MoA временно недоступна (переподключение...)',
-          searchPlaceholder: 'Поиск модели по названию или провайдеру...',
-          modelsFound: 'Найдено',
-          of: 'из',
-          clear: 'Сбросить',
-          noModelsMatch: 'Модели не найдены.',
-          useCustom: 'Использовать кастомное',
-          selectModel: 'Выберите модель...',
-          judgeCriteriaLabel: 'Критерии оценки судьи (опционально):',
-          judgeCriteriaPlaceholder: 'например: Приоритет — производительность, минимум зависимостей, обработка граничных случаев...',
-        },
-      })
+            return ctx.locale.register(NS, locale, dictionary)
           }
-        } catch (err) {
-          console.warn('[dsh-moa] locale registration error:', err)
+        } catch {
+          // Если язык уже занят (например, dsh-russian-lang) или зарегистрирован ранее — уступаем без ошибки
+          return () => {}
         }
+        return () => {}
       }
 
       if (typeof ctx.effect === 'function') {
-        ctx.effect(() => registerLocale(), 'dsh-moa: dictionaries')
+        ctx.effect(() => {
+          const undo = [addLocale('en', en), addLocale('ru', ru)]
+          return () => {
+            for (const off of undo) {
+              if (typeof off === 'function') {
+                try { off() } catch {}
+              }
+            }
+          }
+        }, 'dsh-moa: dictionaries')
       } else {
-        registerLocale()
+        addLocale('en', en)
+        addLocale('ru', ru)
       }
 
-      const t = (key) => {
-        try {
-          if (ctx.locale && typeof ctx.locale.bind === 'function') {
-            return ctx.locale.bind(NS)(key) || key
-          }
-        } catch {}
-        return key
-      }
 
       if (ctx.slots) {
-        const registerDirectSection = () => {
-          try {
-            ctx.slots.register(
-              {
-                name: 'settings.section',
-                id: NS,
-                order: 35,
-                locale: NS,
-                label: () => t('title'),
-                inject: () => ({ ctx, t }),
-              },
-              MoASection
-            )
-          } catch (err) {
-            console.warn('[dsh-moa] Failed to register settings.section:', err)
-          }
-        }
-
-        const registerPluginCard = () => {
+        const registerCard = () => {
           try {
             ctx.slots.register(
               {
@@ -1079,10 +1205,9 @@ window.__ModuleLoader__.load({
                 key: NS,
                 order: 35,
                 locale: NS,
-                label: () => t('title'),
-                inject: () => ({ ctx, t }),
+                inject: () => ({ ctx }),
               },
-              MoACard
+              (props) => React.createElement(MoAErrorBoundary, null, React.createElement(MoACard, props))
             )
           } catch (err) {
             console.warn('[dsh-moa] Failed to register settings.plugin.item:', err)
@@ -1090,11 +1215,9 @@ window.__ModuleLoader__.load({
         }
 
         if (typeof ctx.slots.inject === 'function') {
-          ctx.slots.inject('settings.section', registerDirectSection)
-          ctx.slots.inject('settings.plugin.item', registerPluginCard)
+          ctx.slots.inject('settings.plugin.item', registerCard)
         } else {
-          registerDirectSection()
-          registerPluginCard()
+          registerCard()
         }
       }
 

package/lib/index.js

@@ -1,3 +1,4 @@
+import { refreshCatalogInBackground } from './pricing.js'
 /**
  * DeepSeek Harness Mixture of Agents (MoA) Plugin
  *
@@ -9,7 +10,7 @@
  * 5. Native cost tracking, history logging and leaderboard analytics
  */
 
-import { z } from 'zod'
+import z from '@deepseek-ai/schemastery'
 import path from 'node:path'
 import os from 'node:os'
 import {
@@ -29,6 +30,12 @@ export const inject = ['webServer', 'llm', 'settings', 'sessions', 'tools']
 
 export const NS = 'dsh-moa'
 
+export const PriceRow = z.object({
+  input: z.number().default(0),
+  output: z.number().default(0),
+  cacheHit: z.number().default(0),
+})
+
 export const ModelSlotSchema = z.object({
   provider: z.string().default('opencode-go'),
   model: z.string().default('deepseek-v4-flash'),
@@ -39,16 +46,17 @@ export const PresetSchema = z.object({
   enabled: z.boolean().default(true),
   reference_models: z.array(ModelSlotSchema).default([]),
   aggregator: ModelSlotSchema.default({ provider: 'codex', model: 'gpt-5.6-sol' }),
-  reference_temperature: z.number().min(0).max(2).default(0.6),
-  aggregator_temperature: z.number().min(0).max(2).default(0.4),
-  max_tokens: z.number().int().positive().default(4096),
-  judge_criteria: z.string().optional().default(''),
-  judge_mode: z.enum(['auto', 'review']).optional().default('auto'),
+  reference_temperature: z.number().default(0.6),
+  aggregator_temperature: z.number().default(0.4),
+  max_tokens: z.number().default(4096),
+  judge_criteria: z.string().default(''),
+  judge_mode: z.string().default('auto'),
 })
 
 export const Config = z.object({
   enabled: z.boolean().default(true),
   default_preset: z.string().default('default'),
+  prices: z.dict(PriceRow).default({}),
   presets: z.array(PresetSchema).default([
     {
       name: 'default',
@@ -118,24 +126,26 @@ function readBody(req) {
 }
 
 export function apply(ctx, config) {
-  let currentConfig = Config.parse(config || {})
-  let settingsApi = null
+  refreshCatalogInBackground()
+
+  let settingsScope = null
+  let getConfig = () => config
+  const live = () => Config(structuredClone(getConfig() ?? {})) ?? config
 
   ctx.inject(['settings'], (sctx) => {
     try {
-      settingsApi = sctx.settings.register(NS, Config, { base: currentConfig })
-      const val = settingsApi.get()
-      if (val) currentConfig = Config.parse(val)
-      settingsApi.onChange((next) => {
-        if (next) currentConfig = Config.parse(next)
-      })
+      const scope = sctx.settings.register(NS, Config, { base: config })
+      settingsScope = scope
+      getConfig = () => scope.get() ?? config
+      sctx.effect(() => () => {
+        settingsScope = null
+        getConfig = () => config
+      }, 'dsh-moa: settings')
     } catch (e) {
       console.warn('[dsh-moa] Settings registration warning:', e)
     }
   })
 
-  const getConfig = () => currentConfig
-
   /**
    * Unified LLM dispatch function using ctx.llm.prepareCall / stream
    */
@@ -144,7 +154,21 @@ export function apply(ctx, config) {
       throw new Error('ctx.llm is not available in cordis context')
     }
 
-    const prep = await ctx.llm.prepareCall(provider, model)
+    let prep
+    try {
+      // DSH 0.1.2-rc.1 API expects { provider, model } object
+      prep = await ctx.llm.prepareCall({ provider, model })
+    } catch (err) {
+      if (typeof ctx.llm.prepareCall === 'function') {
+        try {
+          prep = await ctx.llm.prepareCall(provider, model)
+        } catch {
+          throw err
+        }
+      } else {
+        throw err
+      }
+    }
     if (!prep || typeof prep.stream !== 'function') {
       throw new Error(`LLM provider/model ${provider}:${model} could not be prepared`)
     }
@@ -195,7 +219,7 @@ export function apply(ctx, config) {
       kind: 'exact',
       path: '/dsh-moa/status',
       handler: (_req, res) => {
-        const cfg = getConfig()
+        const cfg = live()
         writeJson(res, 200, {
           ok: true,
           enabled: cfg.enabled !== false,
@@ -299,7 +323,7 @@ export function apply(ctx, config) {
       kind: 'exact',
       path: '/dsh-moa/presets',
       handler: async (req, res) => {
-        const cfg = getConfig()
+        const cfg = live()
         if (req.method === 'GET') {
           writeJson(res, 200, {
             ok: true,
@@ -319,24 +343,12 @@ export function apply(ctx, config) {
               presets: Array.isArray(payload.presets) ? payload.presets : (cfg.presets || []),
             }
 
-            // 1. Persist via Cordis Settings API
-            if (settingsApi && typeof settingsApi.replace === 'function') {
-              await settingsApi.replace(newConfig)
-            }
-            currentConfig = newConfig
-
-            // 2. Direct persistence to ~/.dsh/settings.yaml
-            try {
-              const fs = await import('node:fs')
-              const yaml = await import('yaml')
-              const p = path.join(os.homedir(), '.dsh', 'settings.yaml')
-              if (fs.existsSync(p)) {
-                const curYaml = yaml.parse(fs.readFileSync(p, 'utf8')) || {}
-                curYaml[NS] = newConfig
-                fs.writeFileSync(p, yaml.stringify(curYaml), 'utf8')
-              }
-            } catch (fsErr) {
-              console.warn('[dsh-moa] direct file write error:', fsErr)
+            // Persist via Cordis Settings API
+            if (settingsScope && typeof settingsScope.replace === 'function') {
+              await settingsScope.replace(newConfig)
+            } else {
+              // In-memory fallback if settings service is unavailable
+              getConfig = () => newConfig
             }
 
             writeJson(res, 200, {
@@ -418,7 +430,7 @@ export function apply(ctx, config) {
             return
           }
 
-          const cfg = getConfig()
+          const cfg = live()
           const presetName = payload.preset || cfg.default_preset || 'default'
           const preset = (cfg.presets || []).find((p) => p.name === presetName) || cfg.presets?.[0]
 
@@ -450,7 +462,7 @@ export function apply(ctx, config) {
               ? lastUser.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n')
               : '')
 
-        const cfg = getConfig()
+        const cfg = live()
         const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: 'default' }
         const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
 
@@ -487,7 +499,7 @@ export function apply(ctx, config) {
           : '')
 
     if (userText.startsWith('/moa')) {
-      const cfg = getConfig()
+      const cfg = live()
       if (cfg.enabled !== false) {
         if (event.signal) {
           moaPendingSignals.add(event.signal)

package/lib/moa-runner.js

@@ -1,3 +1,4 @@
+import { estimateTokenCost as calculateTokenCost, resolveModelRates, refreshCatalogInBackground, DIRECT_VENDOR_RATES, FALLBACK_RATES } from './pricing.js'
 /**
  * Mixture of Agents (MoA) execution engine with Interactive Questioning,
  * Isolated Multi-Candidate File Execution, Native Cost Tracking,
@@ -59,36 +60,10 @@ The user has provided a prompt that may have multiple design choices, architectu
 Review the user prompt and identify 1 to 3 critical, high-impact clarifying questions or architectural options that would define the implementation (e.g. framework/vanilla, features, design style, target environment).
 Keep questions very clear, structured, and actionable. Avoid trivial questions. Respond directly in Russian.`
 
-/**
- * Built-in pricing table for major LLM model families ($ per 1M tokens) (#10).
- */
-export const MODEL_PRICING_REGISTRY = [
-  { pattern: /deepseek.*flash|v4.*flash/i, inputPerM: 0.14, outputPerM: 0.28 },
-  { pattern: /deepseek.*reasoner|r1/i, inputPerM: 0.55, outputPerM: 2.19 },
-  { pattern: /deepseek/i, inputPerM: 0.27, outputPerM: 1.10 },
-  { pattern: /gpt-4o-mini|gpt-5.*mini/i, inputPerM: 0.15, outputPerM: 0.60 },
-  { pattern: /gpt-5|gpt-4o|sol/i, inputPerM: 2.50, outputPerM: 10.00 },
-  { pattern: /grok/i, inputPerM: 2.00, outputPerM: 10.00 },
-  { pattern: /claude-3-5-sonnet|claude-3-7-sonnet/i, inputPerM: 3.00, outputPerM: 15.00 },
-  { pattern: /claude-3-5-haiku/i, inputPerM: 0.80, outputPerM: 4.00 },
-  { pattern: /claude/i, inputPerM: 3.00, outputPerM: 15.00 },
-  { pattern: /qwen/i, inputPerM: 0.40, outputPerM: 1.20 },
-  { pattern: /commandcode/i, inputPerM: 0.50, outputPerM: 1.50 },
-  { pattern: /.*/, inputPerM: 0.50, outputPerM: 1.50 },
-]
-
-export function estimateTokenCost(slot, usage = {}) {
-  const modelStr = `${slot?.provider || ''} ${slot?.model || ''}`.trim()
-  const match = MODEL_PRICING_REGISTRY.find((p) => p.pattern.test(modelStr)) || MODEL_PRICING_REGISTRY[MODEL_PRICING_REGISTRY.length - 1]
-  const inTokens = usage.inputTokens || usage.promptTokens || usage.input_tokens || 0
-  const outTokens = usage.outputTokens || usage.completionTokens || usage.output_tokens || 0
-  const cost = (inTokens * match.inputPerM / 1_000_000) + (outTokens * match.outputPerM / 1_000_000)
-  return {
-    inputTokens: inTokens,
-    outputTokens: outTokens,
-    totalTokens: inTokens + outTokens,
-    costUsd: Number(cost.toFixed(5)),
-  }
+export { resolveModelRates, refreshCatalogInBackground, DIRECT_VENDOR_RATES, FALLBACK_RATES }
+
+export function estimateTokenCost(slot, usage = {}, customPrices = {}) {
+  return calculateTokenCost(slot, usage, customPrices)
 }
 
 export function slotLabel(slot) {
@@ -323,7 +298,7 @@ export async function runReferencesParallel(references, messages, options = {},
         inputTokens: Math.round(JSON.stringify(fullMessages).length / 4),
         outputTokens: Math.round(text.length / 4),
       }
-      const costInfo = estimateTokenCost(slot, rawUsage)
+      const costInfo = estimateTokenCost(slot, rawUsage, options.prices)
 
       if (typeof onProgress === 'function') {
         const fileMsg = files.length > 0 ? ` (создано файлов: ${files.length})` : ''
@@ -378,6 +353,7 @@ export async function runMoAPipeline({
   cwd,
   onProgress,
   skipQuestions = false,
+  prices = {},
 }) {
   if (typeof callLlm !== 'function') {
     throw new Error('callLlm function is required for runMoAPipeline')
@@ -520,7 +496,7 @@ export async function runMoAPipeline({
         inputTokens: Math.round(synthPrompt.length / 4),
         outputTokens: Math.round(synthesizedText.length / 4),
       }
-      aggUsage = estimateTokenCost(aggregator, rawAggUsage)
+      aggUsage = estimateTokenCost(aggregator, rawAggUsage, prices)
     } catch (err) {
       synthesizedText = `[Aggregator error: ${err?.message || String(err)}]\n\nFallback candidate outputs:\n\n` +
         referenceOutputs.map((r, i) => `### ${r.label}\n${r.text}`).join('\n\n')
@@ -734,7 +710,9 @@ export class MoaRunnerAdapter {
     return { provider, id: model, name: 'MoA Ensemble' }
   }
 
-  async prepareCall(provider, model) {
+  async prepareCall(providerOrConfig, modelOrSignal, _signal) {
+    const provider = typeof providerOrConfig === 'object' && providerOrConfig !== null ? providerOrConfig.provider : providerOrConfig
+    const model = typeof providerOrConfig === 'object' && providerOrConfig !== null ? providerOrConfig.model : modelOrSignal
     return {
       model: { provider, id: model, name: 'MoA Ensemble' },
       stream: (options) => this.stream(options),

package/lib/pricing.js

@@ -0,0 +1,194 @@
+// lib/pricing.js
+// Dynamic pricing registry for @goodandready/dsh-moa.
+//
+// Fetches real-time model rates from the public OpenRouter catalog
+// (https://openrouter.ai/api/v1/models, no auth required), caches rates in
+// ~/.dsh/storages/dsh-moa-catalog.json, and supports direct vendor tariffs
+// and user config overrides in settings.yaml.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+export const CATALOG_URL = 'https://openrouter.ai/api/v1/models'
+export const CACHE_FILE = join(homedir(), '.dsh', 'storages', 'dsh-moa-catalog.json')
+export const REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000 // 24 hours
+
+/**
+ * Direct vendor tariffs (USD per 1M tokens) for official direct routes.
+ */
+export const DIRECT_VENDOR_RATES = {
+  'deepseek-chat': { input: 0.14, output: 0.28, cacheHit: 0.014 },
+  'deepseek-reasoner': { input: 0.55, output: 2.19, cacheHit: 0.14 },
+  'deepseek-v4-flash': { input: 0.14, output: 0.28, cacheHit: 0.014 },
+  'deepseek-v4-pro': { input: 0.55, output: 2.19, cacheHit: 0.044 },
+}
+
+/** Default fallback rate for uncataloged models ($0.50 prompt / $1.50 completion per 1M tokens) */
+export const FALLBACK_RATES = { input: 0.50, output: 1.50, cacheHit: 0.15 }
+
+let memoryCatalog = null
+let lastFetchedAt = 0
+
+/**
+ * Load cached catalog from disk into memory.
+ */
+export function loadCachedCatalog(cachePath = CACHE_FILE) {
+  if (memoryCatalog) return memoryCatalog
+  try {
+    if (existsSync(cachePath)) {
+      const raw = readFileSync(cachePath, 'utf8')
+      const parsed = JSON.parse(raw)
+      if (parsed && typeof parsed.models === 'object') {
+        memoryCatalog = parsed.models
+        lastFetchedAt = parsed.updatedAt || 0
+        return memoryCatalog
+      }
+    }
+  } catch {
+    // Ignore read/parse errors
+  }
+  memoryCatalog = {}
+  return memoryCatalog
+}
+
+/**
+ * Fetch and update catalog from OpenRouter public API.
+ */
+export async function fetchCatalog({
+  url = CATALOG_URL,
+  cachePath = CACHE_FILE,
+  signal = AbortSignal.timeout(5000),
+} = {}) {
+  try {
+    const res = await fetch(url, { signal })
+    if (!res.ok) return loadCachedCatalog(cachePath)
+    const json = await res.json()
+    if (!json || !Array.isArray(json.data)) return loadCachedCatalog(cachePath)
+
+    const models = {}
+    for (const item of json.data) {
+      if (!item.id || !item.pricing) continue
+      const promptPer1M = Number(item.pricing.prompt || 0) * 1e6
+      const completionPer1M = Number(item.pricing.completion || 0) * 1e6
+      const cacheHitPer1M = Number(item.pricing.input_cache_hit || item.pricing.prompt || 0) * 1e6
+
+      models[item.id] = {
+        input: promptPer1M,
+        output: completionPer1M,
+        cacheHit: cacheHitPer1M,
+        contextLength: item.context_length || 0,
+        name: item.name || item.id,
+      }
+    }
+
+    memoryCatalog = models
+    lastFetchedAt = Date.now()
+
+    try {
+      mkdirSync(dirname(cachePath), { recursive: true })
+      writeFileSync(
+        cachePath,
+        JSON.stringify({ updatedAt: lastFetchedAt, count: Object.keys(models).length, models }, null, 2),
+        'utf8',
+      )
+    } catch {
+      // Non-fatal if filesystem is read-only
+    }
+
+    return models
+  } catch {
+    return loadCachedCatalog(cachePath)
+  }
+}
+
+/**
+ * Background refresh catalog if stale (> 24 hours).
+ */
+export function refreshCatalogInBackground(cachePath = CACHE_FILE) {
+  const catalog = loadCachedCatalog(cachePath)
+  const isStale = !lastFetchedAt || Date.now() - lastFetchedAt > REFRESH_INTERVAL_MS
+  if (isStale) {
+    fetchCatalog({ cachePath }).catch(() => {})
+  }
+  return catalog
+}
+
+/**
+ * Resolve price rates (USD per 1M tokens) for a given provider/model slot.
+ */
+export function resolveModelRates(slot = {}, customPrices = {}, cachePath = CACHE_FILE) {
+  const provider = (slot?.provider || '').trim().toLowerCase()
+  const model = (slot?.model || '').trim().toLowerCase()
+  const fullKey = provider ? `${provider}/${model}` : model
+
+  // 1. Check custom user overrides in config
+  if (customPrices && typeof customPrices === 'object') {
+    if (customPrices[fullKey]) return normalizeRates(customPrices[fullKey])
+    if (customPrices[model]) return normalizeRates(customPrices[model])
+    if (provider && customPrices[`${provider}/*`]) return normalizeRates(customPrices[`${provider}/*`])
+    if (customPrices['*']) return normalizeRates(customPrices['*'])
+  }
+
+  // 2. Check direct vendor rates
+  if (DIRECT_VENDOR_RATES[model]) {
+    return { ...DIRECT_VENDOR_RATES[model] }
+  }
+
+  // 3. Check OpenRouter catalog
+  const catalog = loadCachedCatalog(cachePath) || {}
+  
+  if (catalog[fullKey]) return { ...catalog[fullKey] }
+  if (catalog[model]) return { ...catalog[model] }
+
+  for (const [catId, catRate] of Object.entries(catalog)) {
+    const catLower = catId.toLowerCase()
+    if (catLower.endsWith(`/${model}`) || catLower === model) {
+      return { ...catRate }
+    }
+  }
+
+  for (const [catId, catRate] of Object.entries(catalog)) {
+    const catLower = catId.toLowerCase()
+    if (model && (catLower.includes(model) || model.includes(catLower))) {
+      return { ...catRate }
+    }
+  }
+
+  // 4. Fallback rate
+  return { ...FALLBACK_RATES }
+}
+
+function normalizeRates(rate) {
+  if (!rate || typeof rate !== 'object') return { ...FALLBACK_RATES }
+  return {
+    input: Number(rate.input ?? rate.prompt ?? FALLBACK_RATES.input),
+    output: Number(rate.output ?? rate.completion ?? FALLBACK_RATES.output),
+    cacheHit: Number(rate.cacheHit ?? rate.cache_hit ?? FALLBACK_RATES.cacheHit),
+  }
+}
+
+/**
+ * Estimate USD cost and token totals for a single model call.
+ */
+export function estimateTokenCost(slot = {}, usage = {}, customPrices = {}, cachePath = CACHE_FILE) {
+  const promptTokens = usage.prompt_tokens ?? usage.inputTokens ?? usage.input ?? usage.promptTokens ?? 0
+  const completionTokens = usage.completion_tokens ?? usage.outputTokens ?? usage.output ?? usage.completionTokens ?? 0
+  const cacheHitTokens = usage.prompt_tokens_details?.cached_tokens ?? usage.cacheHitTokens ?? 0
+  const totalTokens = promptTokens + completionTokens
+
+  const rates = resolveModelRates(slot, customPrices, cachePath)
+
+  const nonCachedPrompt = Math.max(0, promptTokens - cacheHitTokens)
+  const inputCost = (nonCachedPrompt / 1e6) * rates.input + (cacheHitTokens / 1e6) * rates.cacheHit
+  const outputCost = (completionTokens / 1e6) * rates.output
+  const totalCost = inputCost + outputCost
+
+  return {
+    inputTokens: promptTokens,
+    outputTokens: completionTokens,
+    totalTokens,
+    costUsd: Number(totalCost.toFixed(5)),
+    rates,
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",