@goodandready/dsh-moa 0.2.5 → 0.2.7

package/lib/client.js

@@ -888,14 +888,45 @@ window.__ModuleLoader__.load({
 
     function useMoASettings(props) {
       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) => {
@@ -907,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' })
@@ -926,7 +957,7 @@ window.__ModuleLoader__.load({
           .catch((err) => {
             console.warn('[dsh-moa] Models fetch failed:', err)
           })
-      }, [])
+      }, [scope])
 
       React.useEffect(() => {
         reload()
@@ -934,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' },
@@ -1111,7 +1163,7 @@ window.__ModuleLoader__.load({
       )
     }
 
-    exports.inject = ['slots', 'locale', 'inputTriggers']
+    exports.inject = ['slots', 'locale', 'inputTriggers', 'settingsScope']
     exports.apply = function apply(ctx) {
       rootCtx = ctx
       const t = makeT(ctx)

package/lib/index.js

@@ -16,7 +16,7 @@ import os from 'node:os'
 import {
   parseMoACommand,
   runMoAPipeline,
-  MoaRunnerAdapter,
+  streamMoATurn,
 } from './moa-runner.js'
 
 import {
@@ -450,44 +450,9 @@ export function apply(ctx, config) {
     })
   }, 'dsh-moa: run pipeline route')
 
-  // Register virtual LLM adapter for live-streaming MoA turns
-  if (ctx.llm && typeof ctx.llm.registerAdapter === 'function') {
-    ctx.effect(() => {
-      const adapter = new MoaRunnerAdapter((options) => {
-        const msgs = options.messages || []
-        const lastUser = [...msgs].reverse().find((m) => m && m.role === 'user')
-        const userText = typeof lastUser?.content === 'string'
-          ? lastUser.content
-          : (Array.isArray(lastUser?.content)
-              ? lastUser.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n')
-              : '')
-
-        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]
-
-        const extraCtx = options.signal ? moaPendingContexts.get(options.signal) : null
-        const cwd = options.cwd || extraCtx?.cwd || process.cwd()
-
-        return {
-          targetPreset,
-          userPrompt: parsed.prompt || userText,
-          messages: msgs.slice(0, -1),
-          callLlm,
-          cwd,
-        }
-      })
-
-      const dispose = ctx.llm.registerAdapter(['moa-runner'], adapter)
-      return () => {
-        if (typeof dispose === 'function') dispose()
-      }
-    }, 'dsh-moa: llm adapter')
-  }
-
-  // Session turn interceptor: flag MoA turns and route to moa-runner adapter
-  const moaPendingSignals = new WeakSet()
-  const moaPendingContexts = new WeakMap()
+  // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
+  const moaPendingTurns = new WeakMap()
+  const moaSessionTurns = new Map()
 
   ctx.on('agent/pre-step', async (event, next) => {
     const messages = event.messages || []
@@ -501,10 +466,26 @@ export function apply(ctx, config) {
     if (userText.startsWith('/moa')) {
       const cfg = live()
       if (cfg.enabled !== false) {
+        const parsed = parseMoACommand(userText, cfg.presets || []) || { prompt: userText, presetName: cfg.default_preset || 'default' }
+        const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
+        const aggProvider = targetPreset?.aggregator?.provider || 'codex'
+        const aggModel = targetPreset?.aggregator?.model || 'gpt-5.6-sol'
+        const sessCwd = event.cwd || event.session?.cwd || (event.session?.path ? path.dirname(event.session.path) : undefined) || process.cwd()
+
+        const turnContext = {
+          targetPreset,
+          userPrompt: parsed.prompt || userText,
+          messages: messages.slice(0, -1),
+          cwd: sessCwd,
+          aggregator: { provider: aggProvider, model: aggModel },
+          callLlm,
+        }
+
         if (event.signal) {
-          moaPendingSignals.add(event.signal)
-          const sessCwd = event.cwd || event.session?.cwd || (event.session?.path ? path.dirname(event.session.path) : undefined)
-          moaPendingContexts.set(event.signal, { cwd: sessCwd })
+          moaPendingTurns.set(event.signal, turnContext)
+        }
+        if (event.session?.id) {
+          moaSessionTurns.set(event.session.id, turnContext)
         }
       }
     }
@@ -514,14 +495,32 @@ export function apply(ctx, config) {
 
   ctx.on('agent/request', async (payload, next) => {
     const resolved = await next()
-    if (payload.signal && moaPendingSignals.has(payload.signal)) {
-      moaPendingSignals.delete(payload.signal)
+    const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
+      || (payload.session?.id ? moaSessionTurns.get(payload.session.id) : null)
+
+    if (turnContext) {
       return {
         ...resolved,
-        provider: 'moa-runner',
-        model: 'ensemble',
+        provider: turnContext.aggregator.provider,
+        model: turnContext.aggregator.model,
       }
     }
     return resolved
   })
+
+  ctx.effect(() => {
+    return ctx.on('llm/stream', (options, next) => {
+      const turnContext = (options.signal ? moaPendingTurns.get(options.signal) : null)
+        || (options.session?.id ? moaSessionTurns.get(options.session.id) : null)
+
+      if (turnContext) {
+        if (options.signal) moaPendingTurns.delete(options.signal)
+        if (options.session?.id) moaSessionTurns.delete(options.session.id)
+
+        return streamMoATurn(turnContext, options)
+      }
+
+      return next(options)
+    })
+  }, 'dsh-moa: llm stream interceptor')
 }

package/lib/moa-runner.js

@@ -231,7 +231,7 @@ export function parseMoACommand(text, presets = []) {
     }
   }
 
-  const matchPreset = /^--preset=([a-zA-Z0-9_-]+)\s*(.*)/s.exec(remainder)
+  const matchPreset = /^--preset(?:=|\s+)([a-zA-Z0-9_-]+)\s*(.*)/s.exec(remainder)
   if (matchPreset) {
     return {
       presetName: matchPreset[1],
@@ -684,118 +684,80 @@ export function formatMoAResponse({ moaResult, presetName }) {
   return parts.join('\n')
 }
 
-export class MoaRunnerAdapter {
-  constructor(getMoaContext) {
-    this.getMoaContext = getMoaContext
-  }
-
-  providerInfo(provider) {
-    return { id: provider, name: 'Mixture of Agents Runner' }
-  }
+export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd }, options = {}) {
+  const signal = options?.signal
+  if (signal?.aborted) return
 
-  providerRetryPolicy(_provider) {
-    return undefined
-  }
-
-  imageRequestPricing(_provider, _model) {
-    return undefined
-  }
+  yield { type: 'block-start', index: 0, blockType: 'text' }
+  yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents запущен...*\n\n' }
 
-  async listModels(provider) {
-    const prov = typeof provider === 'string' && provider.length > 0 ? provider : 'moa-runner'
-    return [{ provider: prov, id: 'ensemble', name: 'MoA Ensemble' }]
-  }
-
-  async resolveModel(provider, model) {
-    return { provider, id: model, name: 'MoA Ensemble' }
-  }
-
-  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),
-    }
+  // Queue for streaming progress updates from within runMoAPipeline
+  const progressChunks = []
+  const onProgress = (text) => {
+    progressChunks.push(text)
   }
 
-  async *stream(options) {
-    const signal = options.signal
-    if (signal?.aborted) return
-
-    yield { type: 'block-start', index: 0, blockType: 'text' }
-    yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents запущен...*\n\n' }
-
-    const { targetPreset, userPrompt, messages, callLlm, cwd } = this.getMoaContext(options)
-
-    // Queue for streaming progress updates from within runMoAPipeline
-    const progressChunks = []
-    const onProgress = (text) => {
-      progressChunks.push(text)
-    }
-
-    try {
-      const pipelinePromise = runMoAPipeline({
-        userPrompt,
-        messages,
-        preset: targetPreset,
-        callLlm,
-        cwd,
-        onProgress,
-      })
-
-      const startTime = Date.now()
-      let lastYieldTime = Date.now()
-
-      // Yield progressive updates while pipeline runs
-      while (true) {
-        if (signal?.aborted) return
+  try {
+    const pipelinePromise = runMoAPipeline({
+      userPrompt,
+      messages,
+      preset: targetPreset,
+      callLlm,
+      cwd,
+      onProgress,
+    })
 
-        let emittedAny = false
-        while (progressChunks.length > 0) {
-          const chunk = progressChunks.shift()
-          yield { type: 'text-delta', index: 0, text: chunk }
-          emittedAny = true
-          lastYieldTime = Date.now()
-        }
+    const startTime = Date.now()
+    let lastYieldTime = Date.now()
 
-        const done = await Promise.race([
-          pipelinePromise.then(() => true),
-          new Promise((r) => { const t = setTimeout(() => r(false), 500); t.unref?.(); }),
-        ])
-        if (done) break
-
-        const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
-        // If 3 seconds passed without any progress message, send a live tick
-        if (!emittedAny && Date.now() - lastYieldTime >= 3000) {
-          yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
-          lastYieldTime = Date.now()
-        }
-      }
+    // Yield progressive updates while pipeline runs
+    while (true) {
+      if (signal?.aborted) return
 
+      let emittedAny = false
       while (progressChunks.length > 0) {
         const chunk = progressChunks.shift()
         yield { type: 'text-delta', index: 0, text: chunk }
+        emittedAny = true
+        lastYieldTime = Date.now()
       }
 
-      const moaResult = await pipelinePromise
-      if (signal?.aborted) return
-
-      const formatted = formatMoAResponse({
-        moaResult,
-        presetName: targetPreset?.name || 'default',
-      })
+      const done = await Promise.race([
+        pipelinePromise.then(() => true),
+        new Promise((r) => { const t = setTimeout(() => r(false), 500); t.unref?.(); }),
+      ])
+      if (done) break
+
+      const elapsedSec = Math.floor((Date.now() - startTime) / 1000)
+      // If 3 seconds passed without any progress message, send a live tick
+      if (!emittedAny && Date.now() - lastYieldTime >= 3000) {
+        yield { type: 'text-delta', index: 0, text: `⏳ *[${elapsedSec}с] Идёт обработка...*\n` }
+        lastYieldTime = Date.now()
+      }
+    }
 
-      yield { type: 'text-delta', index: 0, text: '\n---\n\n' + formatted }
-      yield { type: 'block-end', index: 0, block: { type: 'text', text: formatted } }
-      yield { type: 'usage', usage: { inputTokens: moaResult?.usage?.totalTokens || 100, outputTokens: formatted.length } }
-      yield { type: 'finish', reason: { kind: 'stop' } }
-    } catch (err) {
-      if (signal?.aborted) return
-      const errText = '\n\n⚠️ **Ошибка Mixture of Agents**: ' + (err?.message || String(err))
-      yield { type: 'text-delta', index: 0, text: errText }
-      yield { type: 'block-end', index: 0, block: { type: 'text', text: errText } }
-      yield { type: 'finish', reason: { kind: 'stop' } }
+    while (progressChunks.length > 0) {
+      const chunk = progressChunks.shift()
+      yield { type: 'text-delta', index: 0, text: chunk }
     }
+
+    const moaResult = await pipelinePromise
+    if (signal?.aborted) return
+
+    const formatted = formatMoAResponse({
+      moaResult,
+      presetName: targetPreset?.name || 'default',
+    })
+
+    yield { type: 'text-delta', index: 0, text: '\n---\n\n' + formatted }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text: formatted } }
+    yield { type: 'usage', usage: { inputTokens: moaResult?.usage?.totalTokens || 100, outputTokens: formatted.length } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
+  } catch (err) {
+    if (signal?.aborted) return
+    const errText = '\n\n⚠️ **Ошибка Mixture of Agents**: ' + (err?.message || String(err))
+    yield { type: 'text-delta', index: 0, text: errText }
+    yield { type: 'block-end', index: 0, block: { type: 'text', text: errText } }
+    yield { type: 'finish', reason: { kind: 'stop' } }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",
@@ -58,4 +58,4 @@
     "@deepseek-ai/dsh-tools": "^0.1.0-rc.6",
     "@deepseek-ai/schemastery": "^3.18.1"
   }
-}
+}