@apinggithub/mydsh-auto-model-router 0.3.2 → 0.3.4

package/README.md

@@ -63,10 +63,12 @@ LLM dispatch
 | `L2` | writing code, review, refactoring | strong |
 | `L3` | complex bug fixes, multi-step tasks, reports | most powerful |
 
-Each level is a user-assigned provider/model route with a **required**
-`reasoningEffort` (defaults to `off` when omitted): `off` = no thinking mode,
-`high`/`max` = thinking intensity. Levels may be left unconfigured; the router
-then falls to the nearest configured level (direction depends on the cost
+Each level is a user-assigned provider/model route with an **optional**
+`reasoningEffort`: omitting it (or writing `null`) sends no effort at all —
+required for models without a thinking mode (GLM/Qwen flash), which the host
+otherwise rejects; `off` explicitly disables thinking; `high`/`max` set its
+intensity. Levels may be left unconfigured; the router then falls to the nearest
+configured level (direction depends on the cost
 mode).
 
 ## Auto mode in the model selector

package/README.zh.md

@@ -52,9 +52,10 @@ LLM 分发
 | `L2` | 写代码、审查、重构 | 较强 |
 | `L3` | 复杂 BUG 修复、多步任务、汇报 | 最强 |
 
-每个层级是一个用户自行指定的 provider/model 路由，**必须**附带
-`reasoningEffort`（省略时默认 `off`）：`off` = 无思考模式，`high`/`max` =
-思考强度。层级可以留空不配置；路由会落到最近的已配置层级（方向由成本模式决定）。
+每个层级是一个用户自行指定的 provider/model 路由，**可选**附带
+`reasoningEffort`：不写（或写 `null`）= 不发送该字段——GLM/Qwen flash 这类没有
+思考模式的模型**必须**这样，否则宿主会拒绝请求；`off` = 显式关闭思考；`high`/`max`
+= 思考强度。层级可以留空不配置；路由会落到最近的已配置层级（方向由成本模式决定）。
 
 ## 模型选择框中的 Auto 模式
 
@@ -389,14 +390,39 @@ contextGuard: { enabled: true, headroom: 0.85 }
 
 ```powershell
 # 1. 从 npm 装（推荐；peer 范围已放宽为宿主自适应，不需要 allow-version 豁免）
-dsh plugin --profile desktop add '@apinggithub/mydsh-auto-model-router@0.3.1'
+dsh plugin --profile desktop add '@apinggithub/mydsh-auto-model-router@0.3.3'
 
 # 2. 可选：按档位拆账
 dsh plugin --profile desktop add '@apinggithub/dsh-tier-cost@0.1.0'
 
-# 3. 重启 DSH（bundle 只在启动时组合；配置改动用热加载即可）
+# 3. 改完 cordis.patch.yml 后先校验（见下），再重启
+node scripts/check-patch.mjs --profile desktop
+
+# 4. 重启 DSH（bundle 只在启动时组合；配置改动用热加载即可）
 ```
 
+### 改配置前必读：先校验，再重启
+
+`cordis.patch.yml` 里一个少的换行就能让宿主**启动失败**：
+
+```
+DesktopHostFatalError: failed to parse overlay … YAMLException: bad indentation (454:44)
+```
+
+更麻烦的是崩溃对话框里有 **"Disable third-party plugins"** 按钮——点它会把所有第三方
+bundle 从 profile 里摘掉，插件（含 Auto 入口）随之消失，需要手工恢复。
+
+所以每次改完都跑一次（会用宿主自己的解析器校验，并清理临时 profile）：
+
+```powershell
+node scripts/check-patch.mjs --profile desktop
+# PASS  profile "desktop" composes (194 top-level entries)
+# FAIL  … 会打印宿主的原始错误
+```
+
+参数：`--home <DSH_HOME>`、`--profile <name>`、`--file <patch>`（只做静态检查）、`--keep`（保留临时 profile 便于排查）。
+
+
 也可以从源码装：`git clone …` 后 `dsh plugin --profile desktop add ./mydsh-auto-model-router`。
 
 ### 每台机器必须自带档位块

package/config.mjs

@@ -22,7 +22,7 @@
 //   fallbackChain:  [route, ...]  (model-level, appended with the default)
 //   maxRetries:     per-route retry budget on request-error
 
-export const PLUGIN_VERSION = '0.3.2'
+export const PLUGIN_VERSION = '0.3.4'
 
 export const LEVEL_IDS = Object.freeze(['L0', 'L1', 'L2', 'L3'])
 export const COST_MODES = Object.freeze(['cost-first', 'quality-first', 'balanced'])
@@ -382,13 +382,14 @@ function normalizeLevels(levels) {
 }
 
 function normalizeLevelRoute(route, where) {
-  // `reasoningEffort: null` means "this route has no thinking mode at all":
-  // the field is omitted so a provider whose model declares no reasoning
-  // metadata (Zhipu/Bailian flash models) is not rejected with
-  // UNSUPPORTED_REASONING_EFFORT.
-  const omitEffort = route.reasoningEffort === null
+  // A level states a reasoning effort only when the config states one.
+  //
+  // This used to default to 'off', which broke twice over: providers whose
+  // models have no thinking mode (GLM/Qwen flash) reject *any* effort with
+  // UNSUPPORTED_REASONING_EFFORT, and `apply()` normalises the config a second
+  // time, so an omitted field came back as 'off' even when the config had said
+  // `null`. Absent now stays absent, which makes normalisation idempotent.
   const normalized = normalizeRoute(route, where)
-  // Every other level carries an explicit effort; absent → 'off' (no thinking).
   const contextWindow = route.contextWindow === undefined || route.contextWindow === null
     ? undefined
     : Number(route.contextWindow)
@@ -397,7 +398,6 @@ function normalizeLevelRoute(route, where) {
   }
   return {
     ...normalized,
-    ...omitEffort ? {} : { reasoningEffort: normalized.reasoningEffort ?? 'off' },
     // A level may declare that its route is a free-quota route. The flag rides
     // along with the route so the router can prefer/demote it.
     ...route.freeQuota === true ? { freeQuota: true } : {},

package/examples/README.md

@@ -26,7 +26,12 @@ dsh plugin --profile desktop add '@apinggithub/mydsh-auto-model-router@0.3.1'
 # 2. append the levels block to the profile patch
 notepad $env:DSH_HOME\profiles\desktop\cordis.patch.yml
 
-# 3. restart DSH once (bundles compose at boot; later edits hot-reload)
+# 3. ALWAYS validate it before restarting — a YAML typo here stops DSH from
+#    starting, and the crash dialog's "disable third-party plugins" button then
+#    strips every bundle (the router disappears from the model picker)
+node scripts/check-patch.mjs --profile desktop
+
+# 4. restart DSH once (bundles compose at boot; later edits hot-reload)
 ```
 
 Check what the plugin sees at any time:

package/index.mjs

@@ -294,8 +294,29 @@ export function apply(ctx, input = {}) {
     }
   })
 
-  // ── ★ agent/request: reuse the per-input decision ──────────────────────
-  // Only a NEW user input triggers a fresh decision (and only when the
+  /**
+   * Rewrite a host proposal onto one routed model.
+   *
+   * The incoming proposal still carries the *session's* reasoning effort — the
+   * host's model-selection listener re-applies it on every step — and that
+   * value belongs to the virtual `auto` model, not to the model we route to.
+   * Spreading it through sends a thinking parameter to a model that has no
+   * thinking mode, and the host rejects the request with
+   * `provider "zhipu" model "glm-4.7-flash" does not support reasoning effort "off"`.
+   * So the inherited effort is dropped unless the level itself declares one.
+   *
+   * @param {object} proposed - config from the host's own waterfall
+   * @param {object} route - the level's route
+   * @returns {object} the rewritten config
+   */
+  const withRoute = (proposed, route) => {
+    const next = { ...proposed, provider: route.provider, model: route.model }
+    delete next.reasoningEffort
+    if (route.reasoningEffort !== undefined) next.reasoningEffort = route.reasoningEffort
+    return next
+  }
+
+  // ── ★ agent/request: reuse the per-input decision ──────────────────────  // Only a NEW user input triggers a fresh decision (and only when the
   // session picked the virtual auto provider). Steps within the same input
   // reuse state.current — no per-step re-judging, no per-step classifier.
   ctx.on('agent/request', async (payload, next) => {
@@ -333,15 +354,13 @@ export function apply(ctx, input = {}) {
           }
           // fallback: user dismissed → stay in heuristic mode.
           const route = router.current(sessionId)
-          return { ...proposed, provider: route.provider, model: route.model,
-            ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort } }
+          return withRoute(proposed, route)
         }
         if (decision.needsAsk === 'fixed-reelect') {
           const picked = await askFixedLevel(ctx, agentOf(payload), router, sessionId)
           if (picked) router.setMode(sessionId, 'fixed', { fixedLevel: picked })
           const route = router.current(sessionId)
-          return { ...proposed, provider: route.provider, model: route.model,
-            ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort } }
+          return withRoute(proposed, route)
         }
       }
 
@@ -363,15 +382,7 @@ export function apply(ctx, input = {}) {
       if (demotion && config.freeQuota.notify) {
         await notifyFreeQuotaFallback(agentOf(payload), sessionId, demotion, resolveLocale(ctx))
       }
-      return {
-        ...proposed,
-        provider: route.provider,
-        model: route.model,
-        // A level that omits `reasoningEffort` (configured as `null`) has no
-        // thinking mode: sending an effort to a model without reasoning
-        // metadata would be rejected with UNSUPPORTED_REASONING_EFFORT.
-        ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort },
-      }
+      return withRoute(proposed, route)
     } catch (error) {
       // The router must never be able to fail a user request: hand the host's
       // own proposal back untouched and surface the reason once.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apinggithub/mydsh-auto-model-router",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Hybrid model router for DeepSeek Harness: declarative rules, user-configurable cost control (cost-first / quality-first / balanced), optional LLM task classifier, and failure fallback chains.",
   "type": "module",
   "main": "index.mjs",
@@ -26,6 +26,7 @@
     "client.js",
     "cordis.patch.yml",
     "examples",
+    "scripts",
     "README.md",
     "README.zh.md"
   ],
@@ -41,6 +42,7 @@
   "scripts": {
     "test": "node --test *.test.mjs",
     "build:client": "node build-client.mjs",
+    "check:patch": "node scripts/check-patch.mjs",
     "publish:all": "npm publish --access public && cd tier-cost && npm publish --access public"
   },
   "peerDependencies": {

package/scripts/check-patch.mjs

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+// Validate a profile's cordis.patch.yml with the host's own parser.
+//
+// This exists because a single missing newline in the patch (a `- { … }` entry
+// glued to the next key) makes DSH fail at startup with
+//   DesktopHostFatalError: failed to parse overlay … YAMLException
+// and the desktop app offers to "disable third-party plugins", which strips
+// every bundle. Catching it here costs two seconds.
+//
+// The check is authoritative rather than re-implemented: it copies the profile
+// into a throw-away sibling profile and runs `dsh --dump-config`, so the real
+// loader parses the real overlay with the real merge rules.
+//
+// Usage:
+//   node scripts/check-patch.mjs                      # profile "desktop", $DSH_HOME
+//   node scripts/check-patch.mjs --profile web
+//   node scripts/check-patch.mjs --home E:\dsh --profile desktop
+//   node scripts/check-patch.mjs --file path\to\cordis.patch.yml   # syntax only
+//
+// Exit code 0 = the host parsed and composed the profile; 1 = it would not boot.
+import { execFileSync } from 'node:child_process'
+import {
+  copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, rmSync, unlinkSync,
+} from 'node:fs'
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+function parseArgs(argv) {
+  const out = { profile: 'desktop', home: undefined, file: undefined, keep: false }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--profile') out.profile = argv[++i]
+    else if (arg === '--home') out.home = argv[++i]
+    else if (arg === '--file') out.file = argv[++i]
+    else if (arg === '--keep') out.keep = true
+    else if (arg === '--help' || arg === '-h') out.help = true
+    else throw new Error(`unknown argument: ${arg}`)
+  }
+  return out
+}
+
+/** Cheap structural checks that catch the mistakes people actually make. */
+function staticChecks(text) {
+  const problems = []
+  if (text.trim() === '') {
+    problems.push('the file is empty (an empty overlay must still be `[]`)')
+    return problems
+  }
+  if (text.includes('\t')) problems.push('contains a TAB character; YAML forbids tabs for indentation')
+  if (text.charCodeAt(0) === 0xfeff) problems.push('starts with a UTF-8 BOM; write it without one')
+
+  const lines = text.split(/\r?\n/)
+  lines.forEach((line, index) => {
+    // A `}` followed by more content on the same line is the classic
+    // "missing newline between a flow mapping and the next key" breakage.
+    if (/}[ \t]+[A-Za-z_][\w-]*:/.test(line)) {
+      problems.push(`line ${index + 1}: a flow mapping is glued to the next key — missing newline`)
+    }
+  })
+  return problems
+}
+
+/** Windows needs a junction for node_modules; POSIX can use a symlink. */
+function linkModules(target, linkPath) {
+  if (process.platform === 'win32') {
+    execFileSync('cmd', ['/c', 'mklink', '/J', linkPath, target], { stdio: 'pipe' })
+  } else {
+    execFileSync('ln', ['-s', target, linkPath], { stdio: 'pipe' })
+  }
+}
+
+function unlinkModules(linkPath) {
+  if (!existsSync(linkPath)) return
+  const stat = lstatSync(linkPath)
+  if (process.platform === 'win32' && stat.isSymbolicLink()) {
+    execFileSync('cmd', ['/c', 'rmdir', linkPath], { stdio: 'pipe' })
+  } else if (stat.isSymbolicLink()) {
+    unlinkSync(linkPath)
+  } else {
+    rmSync(linkPath, { recursive: true, force: true })
+  }
+}
+
+function main() {
+  const args = parseArgs(process.argv.slice(2))
+  if (args.help) {
+    console.log(readFileSync(new URL(import.meta.url), 'utf8').split('\n').slice(1, 22).join('\n').replace(/^\/\/ ?/gm, ''))
+    return 0
+  }
+
+  const home = args.home ?? process.env.DSH_HOME ?? join(homedir(), '.dsh')
+
+  if (args.file !== undefined) {
+    const patchPath = resolve(args.file)
+    if (!existsSync(patchPath)) {
+      console.error(`FAIL  ${patchPath} does not exist`)
+      return 1
+    }
+    const problems = staticChecks(readFileSync(patchPath, 'utf8'))
+    if (problems.length > 0) {
+      console.error(`FAIL  ${patchPath}`)
+      for (const problem of problems) console.error(`  - ${problem}`)
+      return 1
+    }
+    console.log(`PASS  ${patchPath} (static checks only; run without --file to compose the profile)`)
+    return 0
+  }
+
+  const profileDir = join(home, 'profiles', args.profile)
+  const patchPath = join(profileDir, 'cordis.patch.yml')
+  if (!existsSync(patchPath)) {
+    console.error(`FAIL  no profile patch at ${patchPath}`)
+    return 1
+  }
+
+  const problems = staticChecks(readFileSync(patchPath, 'utf8'))
+  if (problems.length > 0) {
+    console.error(`FAIL  static checks on ${patchPath}`)
+    for (const problem of problems) console.error(`  - ${problem}`)
+    return 1
+  }
+
+  const scratchName = `${args.profile}-check-${process.pid}`
+  const scratchDir = join(home, 'profiles', scratchName)
+  const modulesLink = join(scratchDir, 'node_modules')
+  const realModules = join(profileDir, 'node_modules')
+
+  const cleanup = () => {
+    if (args.keep) {
+      console.log(`kept ${scratchDir}`)
+      return
+    }
+    try { unlinkModules(modulesLink) } catch { /* already gone */ }
+    try { rmSync(scratchDir, { recursive: true, force: true }) } catch { /* best effort */ }
+  }
+
+  try {
+    mkdirSync(scratchDir, { recursive: true })
+    for (const name of ['package.json', 'cordis.patch.yml', 'cordis.yml']) {
+      const from = join(profileDir, name)
+      if (existsSync(from)) copyFileSync(from, join(scratchDir, name))
+    }
+    if (existsSync(realModules)) linkModules(realModules, modulesLink)
+
+    let output = ''
+    let ok = true
+    try {
+      // `dsh` is a .cmd shim on Windows, which execFileSync cannot spawn
+      // directly: go through cmd /c there.
+      const command = process.platform === 'win32' ? 'cmd' : 'dsh'
+      const argv = process.platform === 'win32'
+        ? ['/c', 'dsh', '--profile', scratchName, '--dump-config']
+        : ['--profile', scratchName, '--dump-config']
+      output = execFileSync(command, argv, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: { ...process.env, DSH_HOME: home },
+        timeout: 180_000,
+      })
+    } catch (error) {
+      ok = false
+      output = `${error.stdout ?? ''}${error.stderr ?? ''}` || String(error.message ?? error)
+    }
+
+    if (!ok) {
+      console.error(`FAIL  the host cannot compose profile "${args.profile}"`)
+      const detail = output.split('\n').filter((line) => line.trim() !== '').slice(-25).join('\n')
+      console.error(detail)
+      return 1
+    }
+
+    const entries = (output.match(/^- id: /gm) ?? []).length
+    console.log(`PASS  profile "${args.profile}" composes (${entries} top-level entries)`)
+    console.log(`      ${patchPath}`)
+    return 0
+  } finally {
+    cleanup()
+  }
+}
+
+try {
+  process.exitCode = main()
+} catch (error) {
+  console.error(`FAIL  ${error?.message ?? error}`)
+  process.exitCode = 1
+}