@goodandready/dsh-moa 0.2.34 → 0.2.35

package/lib/index.js

@@ -1,165 +1,36 @@
+import path from 'node:path'
 import { setLogger, logger } from './logger.js'
 import { refreshCatalogInBackground } from './pricing.js'
-/**
- * DeepSeek Harness Mixture of Agents (MoA) Plugin
- *
- * Implements an intelligent ensemble pipeline:
- * 1. User issues /moa <prompt>
- * 2. Parallel candidate proposers write to isolated workspaces (.moa/candidate-X/)
- * 3. Aggregator evaluates and synthesizes the optimal solution
- * 4. Winner candidate files are promoted to the project root
- * 5. Native cost tracking, history logging and leaderboard analytics
- */
-
-import z from '@deepseek-ai/schemastery'
-
-// Ensure .volatile() helper exists on Schemastery schema prototype
-try {
-  const schemaProto = Object.getPrototypeOf(z.boolean())
-  if (schemaProto && typeof schemaProto.volatile !== 'function') {
-    schemaProto.volatile = function () {
-      return typeof this.extra === 'function' ? this.extra('volatile', true) : this
-    }
-  }
-} catch {
-  // safe fallback
-}
-import path from 'node:path'
+import {
+  PriceRow,
+  ModelSlotSchema,
+  PresetSchema,
+  Config,
+  plainConfig,
+} from './moa-schema.js'
+import { createLlmCaller } from './moa-llm.js'
 import {
   parseMoACommand,
   streamMoATurn,
 } from './moa-runner.js'
-
 import { registerMoaRoutes } from './routes.js'
 import { resolvePresetForPrompt } from './moa-router.js'
-
 import { createLiveCanvasClient } from './live-canvas.js'
 import { registerPluginUpdater } from './updater.js'
 
 export const name = '@goodandready/dsh-moa'
 export { collectProjectContext, formatProjectContext } from './file-workspace.js'
 export const inject = ['webServer', 'llm', '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(''),
-  model: z.string().default(''),
-  role_persona: z.string().default(''),
-  temperature: z.number().default(-1),
-})
-
-export const PresetSchema = z.object({
-  name: z.string(),
-  enabled: z.boolean().default(true),
-  ask_clarifying_questions: z.boolean().default(true),
-  curator_synthesis: z.boolean().default(false),
-  stream_aggregator: z.boolean().default(true),
-  quorum_enabled: z.boolean().default(false),
-  grace_period_sec: z.number().default(10),
-  reference_models: z.array(ModelSlotSchema).default([]),
-  aggregator: ModelSlotSchema.default({ provider: '', model: '' }),
-  aggregator_fallbacks: z.array(ModelSlotSchema).default([]),
-  reference_temperature: z.number().default(0.6),
-  aggregator_temperature: z.number().default(0.4),
-  reference_timeout_sec: z.number().default(60),
-  aggregator_timeout_sec: z.number().default(180),
-  blind_evaluation: z.boolean().default(false),
-  peer_critique_enabled: z.boolean().default(false),
-  allow_candidate_override: z.boolean().default(false),
-  max_tokens: z.number().default(4096),
-  judge_criteria: z.string().default(''),
-  test_gate_enabled: z.boolean().default(false),
-  test_command: z.string().default(''),
-  test_gate_timeout_sec: z.number().default(15),
-  multi_judge_enabled: z.boolean().default(false),
-  judge_models: z.array(ModelSlotSchema).default([]),
-  judge_voting_strategy: z.string().default('majority'),
-  composite_merge_enabled: z.boolean().default(false),
-  smart_routing_enabled: z.boolean().default(false),
-  smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }),
-  budget_guard_enabled: z.boolean().default(false),
-  max_budget_usd: z.number().default(0),
-  budget_action: z.string().default('trim'),
-  temperature_gradient_enabled: z.boolean().default(false),
-  multi_turn_enabled: z.boolean().default(true),
-  report_generation_enabled: z.boolean().default(false),
-  local_fallback_enabled: z.boolean().default(false),
-  local_fallback_models: z.array(ModelSlotSchema).default([]),
-})
-
-export const Config = z.object({
-  enabled: z.boolean().default(true).volatile(),
-  default_preset: z.string().default('default').volatile(),
-  smart_routing_enabled: z.boolean().default(false).volatile(),
-  smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
-  prices: z.dict(PriceRow).default({}).volatile(),
-  presets: z.array(PresetSchema).default([
-    {
-      name: 'default',
-      enabled: true,
-      ask_clarifying_questions: true,
-      reference_models: [
-        { provider: '', model: '', role_persona: 'proposer' },
-        { provider: '', model: '', role_persona: 'challenger' },
-      ],
-      aggregator: { provider: '', model: '' },
-      reference_temperature: 0.6,
-      aggregator_temperature: 0.4,
-      max_tokens: 4096,
-      judge_criteria: '',
-    },
-    {
-      name: 'fast',
-      enabled: true,
-      ask_clarifying_questions: false,
-      reference_models: [
-        { provider: '', model: '', role_persona: 'fast' },
-      ],
-      aggregator: { provider: '', model: '' },
-      reference_temperature: 0.6,
-      aggregator_temperature: 0.2,
-      max_tokens: 4096,
-      judge_criteria: '',
-    },
-    {
-      name: 'deep-reasoning',
-      enabled: true,
-      ask_clarifying_questions: true,
-      reference_models: [
-        { provider: '', model: '', role_persona: 'architect' },
-        { provider: '', model: '', role_persona: 'critic' },
-      ],
-      aggregator: { provider: '', model: '' },
-      reference_temperature: 0.6,
-      aggregator_temperature: 0.2,
-      max_tokens: 8192,
-      judge_criteria: '',
-    },
-  ]).volatile(),
-})
-
-
-export function plainConfig(value) {
-  if (value && typeof value === 'object' && typeof value.get === 'function') {
-    return plainConfig(value.get())
-  }
-  if (Array.isArray(value)) {
-    return value.map(plainConfig)
-  }
-  if (value !== null && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value).map(([key, child]) => [key, plainConfig(child)])
-    )
-  }
-  return value
-}
+export {
+  PriceRow,
+  ModelSlotSchema,
+  PresetSchema,
+  Config,
+  plainConfig,
+} from './moa-schema.js'
+export { createLlmCaller } from './moa-llm.js'
 
 export function apply(ctx, config) {
   if (ctx.logger) setLogger(ctx.logger)
@@ -214,76 +85,7 @@ export function apply(ctx, config) {
     return localConfig
   }
 
-  /**
-   * Unified LLM dispatch function using ctx.llm.prepareCall / stream
-   */
-  const callLlm = async ({ provider, model, messages, temperature = 0.6, maxTokens = 4096, timeoutMs, onStreamDelta }) => {
-    if (!ctx.llm) {
-      throw new Error('ctx.llm is not available in cordis context')
-    }
-
-    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`)
-    }
-
-    const effectiveTimeoutMs = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : 120000
-    const abortCtrl = new AbortController()
-    const timeoutId = setTimeout(() => abortCtrl.abort(new Error(`LLM call timeout after ${Math.round(effectiveTimeoutMs / 1000)}s`)), effectiveTimeoutMs)
-    timeoutId.unref?.()
-
-    try {
-      const stream = prep.stream({
-        messages,
-        temperature,
-        maxTokens,
-        signal: abortCtrl.signal,
-      })
-
-      let fullText = ''
-      let usageInfo = null
-
-      for await (const chunk of stream) {
-        if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
-          fullText += chunk.text
-          if (typeof onStreamDelta === 'function') {
-            onStreamDelta(chunk.text)
-          }
-        } else if (chunk.type === 'block-end' && chunk.block?.text) {
-          if (!fullText) fullText = chunk.block.text
-        } else if (chunk.type === 'usage' && chunk.usage) {
-          usageInfo = chunk.usage
-        }
-      }
-
-      clearTimeout(timeoutId)
-      return {
-        content: fullText,
-        text: fullText,
-        usage: usageInfo || {
-          inputTokens: Math.round(JSON.stringify(messages).length / 4),
-          outputTokens: Math.round(fullText.length / 4),
-        },
-      }
-    } catch (err) {
-      clearTimeout(timeoutId)
-      throw err
-    }
-  }
+  const callLlm = createLlmCaller(ctx)
 
   // Optional Live Canvas preview client: the harness port is resolved per
   // call and any failure degrades to "no preview link" (live-canvas is not
@@ -311,7 +113,6 @@ export function apply(ctx, config) {
   })
 
   // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
-
   ctx.effect(() => {
     return () => {
       for (const entry of moaSessionTurns.values()) {
@@ -354,81 +155,81 @@ export function apply(ctx, config) {
 
   ctx.effect(() => {
     return ctx.on('agent/pre-step', async (event, next) => {
-    const messages = event.messages || []
-    const lastUserMsg = [...messages].reverse().find((m) => m && m.role === 'user')
-    const userText = typeof lastUserMsg?.content === 'string'
-      ? lastUserMsg.content.trim()
-      : (Array.isArray(lastUserMsg?.content)
-          ? lastUserMsg.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n').trim()
-          : '')
-
-    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 isExplicitPreset = userText.includes('--preset') || userText.includes('-p ')
-        if (!isExplicitPreset && (cfg.smart_routing_enabled || cfg.presets?.some((p) => p.smart_routing_enabled))) {
-          try {
-            const routed = await resolvePresetForPrompt({
-              prompt: parsed.prompt || userText,
-              presets: cfg.presets || [],
-              defaultPreset: parsed.presetName || cfg.default_preset || 'default',
-              routingModel: cfg.smart_routing_model,
-              callLlm,
-              enabled: true,
-            })
-            if (routed?.isAutoRouted && routed.presetName) {
-              parsed.presetName = routed.presetName
+      const messages = event.messages || []
+      const lastUserMsg = [...messages].reverse().find((m) => m && m.role === 'user')
+      const userText = typeof lastUserMsg?.content === 'string'
+        ? lastUserMsg.content.trim()
+        : (Array.isArray(lastUserMsg?.content)
+            ? lastUserMsg.content.filter((p) => p.type === 'text').map((p) => p.text).join('\n').trim()
+            : '')
+
+      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 isExplicitPreset = userText.includes('--preset') || userText.includes('-p ')
+          if (!isExplicitPreset && (cfg.smart_routing_enabled || cfg.presets?.some((p) => p.smart_routing_enabled))) {
+            try {
+              const routed = await resolvePresetForPrompt({
+                prompt: parsed.prompt || userText,
+                presets: cfg.presets || [],
+                defaultPreset: parsed.presetName || cfg.default_preset || 'default',
+                routingModel: cfg.smart_routing_model,
+                callLlm,
+                enabled: true,
+              })
+              if (routed?.isAutoRouted && routed.presetName) {
+                parsed.presetName = routed.presetName
+              }
+            } catch {
+              // fallback silently
             }
-          } catch {
-            // fallback silently
           }
-        }
-        const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
-        const aggProvider = targetPreset?.aggregator?.provider || ''
-        const aggModel = targetPreset?.aggregator?.model || ''
-        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,
-          prices: cfg.prices || {},
-          liveCanvas,
-          webServerPort: ctx.webServer?.port,
-          timeMachineEngine: ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
-        }
+          const targetPreset = (cfg.presets || []).find((p) => p.name === parsed.presetName) || cfg.presets?.[0]
+          const aggProvider = targetPreset?.aggregator?.provider || ''
+          const aggModel = targetPreset?.aggregator?.model || ''
+          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,
+            prices: cfg.prices || {},
+            liveCanvas,
+            webServerPort: ctx.webServer?.port,
+            timeMachineEngine: ctx.get?.('timeMachineEngine') || ctx.timeMachineEngine,
+          }
 
-        if (event.signal) {
-          moaPendingTurns.set(event.signal, turnContext)
-        }
-        if (event.session?.id) {
-          setSessionTurn(event.session.id, turnContext)
+          if (event.signal) {
+            moaPendingTurns.set(event.signal, turnContext)
+          }
+          if (event.session?.id) {
+            setSessionTurn(event.session.id, turnContext)
+          }
         }
       }
-    }
 
-    return next()
+      return next()
     })
   }, 'dsh-moa: agent pre-step interceptor')
 
   ctx.effect(() => {
     return ctx.on('agent/request', async (payload, next) => {
-    const resolved = await next()
-    const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
-      || (payload.session?.id ? getSessionTurn(payload.session.id) : null)
+      const resolved = await next()
+      const turnContext = (payload.signal ? moaPendingTurns.get(payload.signal) : null)
+        || (payload.session?.id ? getSessionTurn(payload.session.id) : null)
 
-    if (turnContext) {
-      return {
-        ...resolved,
-        provider: turnContext.aggregator.provider,
-        model: turnContext.aggregator.model,
+      if (turnContext) {
+        return {
+          ...resolved,
+          provider: turnContext.aggregator.provider,
+          model: turnContext.aggregator.model,
+        }
       }
-    }
-    return resolved
+      return resolved
     })
   }, 'dsh-moa: agent request interceptor')
 

package/lib/moa-llm.js

@@ -0,0 +1,73 @@
+/**
+ * Unified LLM Dispatcher using ctx.llm.prepareCall / stream
+ */
+
+export function createLlmCaller(ctx) {
+  return async ({ provider, model, messages, temperature = 0.6, maxTokens = 4096, timeoutMs, onStreamDelta }) => {
+    if (!ctx.llm) {
+      throw new Error('ctx.llm is not available in cordis context')
+    }
+
+    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`)
+    }
+
+    const effectiveTimeoutMs = typeof timeoutMs === 'number' && timeoutMs > 0 ? timeoutMs : 120000
+    const abortCtrl = new AbortController()
+    const timeoutId = setTimeout(() => abortCtrl.abort(new Error(`LLM call timeout after ${Math.round(effectiveTimeoutMs / 1000)}s`)), effectiveTimeoutMs)
+    timeoutId.unref?.()
+
+    try {
+      const stream = prep.stream({
+        messages,
+        temperature,
+        maxTokens,
+        signal: abortCtrl.signal,
+      })
+
+      let fullText = ''
+      let usageInfo = null
+
+      for await (const chunk of stream) {
+        if (chunk.type === 'text-delta' && typeof chunk.text === 'string') {
+          fullText += chunk.text
+          if (typeof onStreamDelta === 'function') {
+            onStreamDelta(chunk.text)
+          }
+        } else if (chunk.type === 'block-end' && chunk.block?.text) {
+          if (!fullText) fullText = chunk.block.text
+        } else if (chunk.type === 'usage' && chunk.usage) {
+          usageInfo = chunk.usage
+        }
+      }
+
+      clearTimeout(timeoutId)
+      return {
+        content: fullText,
+        text: fullText,
+        usage: usageInfo || {
+          inputTokens: Math.round(JSON.stringify(messages).length / 4),
+          outputTokens: Math.round(fullText.length / 4),
+        },
+      }
+    } catch (err) {
+      clearTimeout(timeoutId)
+      throw err
+    }
+  }
+}

package/lib/moa-schema.js

@@ -0,0 +1,131 @@
+import z from '@deepseek-ai/schemastery'
+
+// Ensure .volatile() helper exists on Schemastery schema prototype
+try {
+  const schemaProto = Object.getPrototypeOf(z.boolean())
+  if (schemaProto && typeof schemaProto.volatile !== 'function') {
+    schemaProto.volatile = function () {
+      return typeof this.extra === 'function' ? this.extra('volatile', true) : this
+    }
+  }
+} catch {
+  // safe fallback
+}
+
+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(''),
+  model: z.string().default(''),
+  role_persona: z.string().default(''),
+  temperature: z.number().default(-1),
+})
+
+export const PresetSchema = z.object({
+  name: z.string(),
+  enabled: z.boolean().default(true),
+  ask_clarifying_questions: z.boolean().default(true),
+  curator_synthesis: z.boolean().default(false),
+  stream_aggregator: z.boolean().default(true),
+  quorum_enabled: z.boolean().default(false),
+  grace_period_sec: z.number().default(10),
+  reference_models: z.array(ModelSlotSchema).default([]),
+  aggregator: ModelSlotSchema.default({ provider: '', model: '' }),
+  aggregator_fallbacks: z.array(ModelSlotSchema).default([]),
+  reference_temperature: z.number().default(0.6),
+  aggregator_temperature: z.number().default(0.4),
+  reference_timeout_sec: z.number().default(60),
+  aggregator_timeout_sec: z.number().default(180),
+  blind_evaluation: z.boolean().default(false),
+  peer_critique_enabled: z.boolean().default(false),
+  allow_candidate_override: z.boolean().default(false),
+  max_tokens: z.number().default(4096),
+  judge_criteria: z.string().default(''),
+  test_gate_enabled: z.boolean().default(false),
+  test_command: z.string().default(''),
+  test_gate_timeout_sec: z.number().default(15),
+  multi_judge_enabled: z.boolean().default(false),
+  judge_models: z.array(ModelSlotSchema).default([]),
+  judge_voting_strategy: z.string().default('majority'),
+  composite_merge_enabled: z.boolean().default(false),
+  smart_routing_enabled: z.boolean().default(false),
+  smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }),
+  budget_guard_enabled: z.boolean().default(false),
+  max_budget_usd: z.number().default(0),
+  budget_action: z.string().default('trim'),
+  temperature_gradient_enabled: z.boolean().default(false),
+  multi_turn_enabled: z.boolean().default(true),
+  report_generation_enabled: z.boolean().default(false),
+  local_fallback_enabled: z.boolean().default(false),
+  local_fallback_models: z.array(ModelSlotSchema).default([]),
+})
+
+export const Config = z.object({
+  enabled: z.boolean().default(true).volatile(),
+  default_preset: z.string().default('default').volatile(),
+  smart_routing_enabled: z.boolean().default(false).volatile(),
+  smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
+  prices: z.dict(PriceRow).default({}).volatile(),
+  presets: z.array(PresetSchema).default([
+    {
+      name: 'default',
+      enabled: true,
+      ask_clarifying_questions: true,
+      reference_models: [
+        { provider: '', model: '', role_persona: 'proposer' },
+        { provider: '', model: '', role_persona: 'challenger' },
+      ],
+      aggregator: { provider: '', model: '' },
+      reference_temperature: 0.6,
+      aggregator_temperature: 0.4,
+      max_tokens: 4096,
+      judge_criteria: '',
+    },
+    {
+      name: 'fast',
+      enabled: true,
+      ask_clarifying_questions: false,
+      reference_models: [
+        { provider: '', model: '', role_persona: 'fast' },
+      ],
+      aggregator: { provider: '', model: '' },
+      reference_temperature: 0.6,
+      aggregator_temperature: 0.2,
+      max_tokens: 4096,
+      judge_criteria: '',
+    },
+    {
+      name: 'deep-reasoning',
+      enabled: true,
+      ask_clarifying_questions: true,
+      reference_models: [
+        { provider: '', model: '', role_persona: 'architect' },
+        { provider: '', model: '', role_persona: 'critic' },
+      ],
+      aggregator: { provider: '', model: '' },
+      reference_temperature: 0.6,
+      aggregator_temperature: 0.2,
+      max_tokens: 8192,
+      judge_criteria: '',
+    },
+  ]).volatile(),
+})
+
+export function plainConfig(value) {
+  if (value && typeof value === 'object' && typeof value.get === 'function') {
+    return plainConfig(value.get())
+  }
+  if (Array.isArray(value)) {
+    return value.map(plainConfig)
+  }
+  if (value !== null && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, child]) => [key, plainConfig(child)])
+    )
+  }
+  return value
+}

package/lib/moa-stream.js

@@ -13,53 +13,62 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
   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 started...*\n\n' }
-
-  // Async push-queue for zero-latency live delta streaming
-  const queue = []
-  let notify = null
-
-  const pushUpdate = (text) => {
-    queue.push({ type: 'text-delta', index: 0, text })
-    if (notify) {
-      notify()
-      notify = null
-    }
+  const internalAbortCtrl = new AbortController()
+  let combinedSignal = internalAbortCtrl.signal
+  if (typeof AbortSignal?.any === 'function' && (signal instanceof AbortSignal)) {
+    combinedSignal = AbortSignal.any([signal, internalAbortCtrl.signal])
+  } else if (signal && typeof signal.addEventListener === 'function') {
+    signal.addEventListener('abort', () => internalAbortCtrl.abort(), { once: true })
   }
 
   let done = false
-  const pipelinePromise = runMoAPipeline({
-    userPrompt,
-    messages,
-    preset: targetPreset,
-    callLlm,
-    cwd,
-    onProgress: pushUpdate,
-    onStreamDelta: (delta) => pushUpdate(delta),
-    prices,
-    historyFilePath,
-    liveCanvas,
-    webServerPort,
-    timeMachineEngine,
-    force,
-    signal,
-  })
-    .catch((err) => ({ error: err }))
-    .finally(() => {
-      done = true
+
+  try {
+    yield { type: 'block-start', index: 0, blockType: 'text' }
+    yield { type: 'text-delta', index: 0, text: '🧠 *Mixture of Agents started...*\n\n' }
+
+    // Async push-queue for zero-latency live delta streaming
+    const queue = []
+    let notify = null
+
+    const pushUpdate = (text) => {
+      queue.push({ type: 'text-delta', index: 0, text })
       if (notify) {
         notify()
         notify = null
       }
-    })
+    }
 
-  const startTime = Date.now()
-  let lastYieldTime = Date.now()
+    const pipelinePromise = runMoAPipeline({
+      userPrompt,
+      messages,
+      preset: targetPreset,
+      callLlm,
+      cwd,
+      onProgress: pushUpdate,
+      onStreamDelta: (delta) => pushUpdate(delta),
+      prices,
+      historyFilePath,
+      liveCanvas,
+      webServerPort,
+      timeMachineEngine,
+      force,
+      signal: combinedSignal,
+    })
+      .catch((err) => ({ error: err }))
+      .finally(() => {
+        done = true
+        if (notify) {
+          notify()
+          notify = null
+        }
+      })
+
+    const startTime = Date.now()
+    let lastYieldTime = Date.now()
 
-  try {
     while (!done || queue.length > 0) {
-      if (signal?.aborted) {
+      if (combinedSignal.aborted) {
         await cleanMoaWorkspaces(cwd)
         return
       }
@@ -86,7 +95,7 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     }
 
     const result = await pipelinePromise
-    if (signal?.aborted) {
+    if (combinedSignal.aborted) {
       await cleanMoaWorkspaces(cwd)
       return
     }
@@ -115,6 +124,9 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
     }
     yield { type: 'finish', reason: { kind: 'stop' } }
   } finally {
-    // cleanup
+    internalAbortCtrl.abort()
+    if (!done) {
+      await cleanMoaWorkspaces(cwd).catch(() => {})
+    }
   }
 }

package/lib/pricing.js

@@ -25,7 +25,6 @@ export function getDefaultCacheFile() {
   return join(baseDir, 'storages', 'dsh-moa-catalog.json')
 }
 
-export const CACHE_FILE = getDefaultCacheFile()
 export const REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000 // 24 hours
 
 /**
@@ -34,8 +33,6 @@ export const REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000 // 24 hours
 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) */

package/lib/routes.js

@@ -198,9 +198,13 @@ ctx.effect(() => {
             const raw = await readBody(req)
             const payload = JSON.parse(raw)
             const newConfig = {
+              ...cfg,
               enabled: typeof payload.enabled === 'boolean' ? payload.enabled : cfg.enabled !== false,
               default_preset: payload.default_preset || cfg.default_preset || 'default',
               presets: Array.isArray(payload.presets) ? payload.presets : (cfg.presets || []),
+              ...(payload.prices !== undefined ? { prices: payload.prices } : {}),
+              ...(payload.smart_routing_enabled !== undefined ? { smart_routing_enabled: payload.smart_routing_enabled } : {}),
+              ...(payload.smart_routing_model !== undefined ? { smart_routing_model: payload.smart_routing_model } : {}),
             }
 
             // Validate the merged payload through the plugin schema before it

package/package.json

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