@apinggithub/mydsh-auto-model-router 0.2.2 → 0.2.4

package/auto-adapter.mjs

@@ -107,6 +107,49 @@ function reasoningEfforts(info) {
   return FALLBACK_EFFORTS.map((effort) => ({ ...effort }))
 }
 
+/**
+ * Pick the reasoning effort to send to the routed model.
+ *
+ * The session's model selection keeps its own `reasoningEffort` and the host's
+ * selection listener re-applies it after every waterfall rewrite, so the value
+ * that reaches this adapter belongs to the *virtual* model, not to the model it
+ * forwards to. Passing it through unchanged sends a thinking parameter to a
+ * model with no thinking mode, which the provider rejects outright
+ * (`does not support reasoning effort "low"`).
+ *
+ * @param {object} llm - ctx.llm
+ * @param {object} route - the routed provider/model
+ * @param {unknown} requested - effort the caller asked for (usually the UI choice)
+ * @returns {Promise<string | undefined>} an effort the target advertises, or undefined
+ */
+async function supportedEffort(llm, route, requested) {
+  const info = await underlyingInfo(llm, route)
+  const efforts = Array.isArray(info?.reasoning?.efforts) ? info.reasoning.efforts : []
+  if (efforts.length === 0) return undefined
+  const ids = new Set(efforts.map((effort) => effort.id))
+  if (typeof route.reasoningEffort === 'string' && ids.has(route.reasoningEffort)) return route.reasoningEffort
+  if (typeof requested === 'string' && ids.has(requested)) return requested
+  const fallback = info?.reasoning?.defaultEffort
+  return typeof fallback === 'string' && ids.has(fallback) ? fallback : undefined
+}
+
+/**
+ * Request options for the routed model: same call, different provider/model,
+ * and only the reasoning effort that model actually supports.
+ *
+ * @param {object} llm - ctx.llm
+ * @param {object} route - the routed provider/model
+ * @param {object} options - options the runtime handed to `stream()`
+ * @returns {Promise<object>}
+ */
+async function forwardOptions(llm, route, options) {
+  const forwarded = { ...options, provider: route.provider, model: route.model }
+  delete forwarded.reasoningEffort
+  const effort = await supportedEffort(llm, route, options?.reasoningEffort)
+  if (effort !== undefined) forwarded.reasoningEffort = effort
+  return forwarded
+}
+
 /**
  * Build the virtual adapter for one plugin mount.
  *
@@ -194,13 +237,9 @@ export function createAutoAdapter(resolve = {}) {
           // runtime; the adapter contract requires we stream chunks back.
           const llm = readLlm()
           if (typeof llm?.stream === 'function') {
+            const forwarded = await forwardOptions(llm, route, options)
             // ctx.llm.stream returns the AsyncIterable directly (not { stream }).
-            const stream = llm.stream({
-              ...options,
-              provider: route.provider,
-              model: route.model,
-              ...route.reasoningEffort === undefined ? {} : { reasoningEffort: route.reasoningEffort },
-            })
+            const stream = llm.stream(forwarded)
             for await (const chunk of stream) yield chunk
             return
           }

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.2.2'
+export const PLUGIN_VERSION = '0.2.4'
 
 export const LEVEL_IDS = Object.freeze(['L0', 'L1', 'L2', 'L3'])
 export const COST_MODES = Object.freeze(['cost-first', 'quality-first', 'balanced'])
@@ -297,9 +297,13 @@ 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
   const normalized = normalizeRoute(route, where)
-  // Levels always carry an explicit reasoning effort; absent → 'off' (no
-  // thinking mode) so every level spells out its thinking intensity.
+  // Every other level carries an explicit effort; absent → 'off' (no thinking).
   const contextWindow = route.contextWindow === undefined || route.contextWindow === null
     ? undefined
     : Number(route.contextWindow)
@@ -308,7 +312,7 @@ function normalizeLevelRoute(route, where) {
   }
   return {
     ...normalized,
-    reasoningEffort: normalized.reasoningEffort ?? 'off',
+    ...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 } : {},
@@ -328,7 +332,7 @@ function normalizeRoute(route, where) {
       `mydsh-auto-model-router: "${where}" needs both provider and model, got ${JSON.stringify(route)}`,
     )
   }
-  const reasoningEffort = route.reasoningEffort === undefined
+  const reasoningEffort = route.reasoningEffort === undefined || route.reasoningEffort === null
     ? undefined
     : String(route.reasoningEffort).trim() || undefined
   return {

package/index.mjs

@@ -341,9 +341,10 @@ export function apply(ctx, input = {}) {
         ...proposed,
         provider: route.provider,
         model: route.model,
-        // Levels always carry an explicit reasoningEffort (default 'off'), so
-        // the routed effort is always stated — including 'off' for no thinking.
-        reasoningEffort: route.reasoningEffort,
+        // 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 },
       }
     } catch (error) {
       // The router must never be able to fail a user request: hand the host's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apinggithub/mydsh-auto-model-router",
-  "version": "0.2.2",
+  "version": "0.2.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",