auto-model-router 0.7.1 → 0.7.2

package/.omp-plugin/marketplace.json

@@ -7,14 +7,14 @@
   },
   "metadata": {
     "description": "auto-model-router: a local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
-    "version": "0.7.1",
+    "version": "0.7.2",
     "pluginRoot": "."
   },
   "plugins": [
     {
       "name": "auto-model-router",
       "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter. Runs in-process, routes per turn by price and task complexity, with budget caps, mid-stream escalation, and cache-aware hysteresis.",
-      "version": "0.7.1",
+      "version": "0.7.2",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/README.md

@@ -907,6 +907,7 @@ Each task (`coding`, `vision`, `documentation`, `data`, `chat`) is a
 | `minTrustSamples` | `12` | Attempts before trust is enforced. |
 | `trustScopedByHarness` | `false` | `true` = each harness reads only its own trust rows. |
 | `contextHeadroom` | `1.25` | Fraction of context kept free (a model must fit prompt × this). |
+| `reasoningCompletionFloor` | `512` | Smallest completion budget a **reasoning** model is dispatched with. A reasoning model spends the budget thinking before it answers, so a caller's tight cap (omp asks ~12 tokens for a conversation title) returns nothing: measured on `ollama/gpt-oss:20b`, which hit the cap having produced no content and cost a dead dispatch plus a failover. Raised only for models that reason, never above the model's own ceiling, and a cap is an upper bound so a direct answer still stops early. 0 disables. |
 | `latencyWeight` | `0` | How hard to penalise slow models in scoring (soft multiplier on effective cost). `0` disables it. |
 | `latencyMinSamples` | `20` | Streamed samples before latency is judged against a model. |
 | `cacheReliabilityMinSamples` | `10` | Warm-expected samples before a model's observed cache hit rate discounts its "stay warm" price in the stay/switch comparison. A model whose cache misses when it should be warm (measured: 5-6% on glm/gemini, 11% on ling, 50% on nex) is kept less eagerly. `0` assumes every cache is reliable. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/cli/config-wizard.ts

@@ -189,6 +189,7 @@ export const WIZARD_SECTIONS: readonly SectionSpec[] = [
 			{ path: "filters.trustScopedByHarness", label: "Scope trust per harness", kind: "boolean" },
 			{ path: "filters.trustWindowDays", label: "Trust window", kind: "number", min: 0, hint: "days, 0=all time" },
 			{ path: "filters.contextHeadroom", label: "Context headroom", kind: "number", min: 1 },
+			{ path: "filters.reasoningCompletionFloor", label: "Reasoning completion floor", kind: "number", min: 0 },
 			{ path: "filters.latencyWeight", label: "Latency weight", kind: "number", min: 0, hint: "0=ignore speed" },
 			{ path: "filters.latencyReferenceMs", label: "Latency reference TTFT", kind: "number", min: 1, hint: "ms" },
 			{ path: "filters.latencyReferenceTokensPerSec", label: "Latency reference speed", kind: "number", min: 1, hint: "tok/s" },

package/src/config/defaults.ts

@@ -114,6 +114,10 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		// opt-in after a replay run prices it.
 		trustWindowDays: 0,
 		contextHeadroom: 1.25,
+		// Enough for a short chain of thought plus a brief answer. Measured against
+		// the failure it fixes: gpt-oss:20b and nemotron-3-nano returned empty at a
+		// 12-token cap, then failed over.
+		reasoningCompletionFloor: 512,
 		// Latency scoring is off by default (weight 0): opt in after establishing a
 		// baseline. Expected total wait (TTFT + expected completion / throughput)
 		// above the references inflates a model's effective cost.

package/src/config/schema.ts

@@ -95,6 +95,7 @@ const filters = z.strictObject({
 	trustScopedByHarness: z.boolean().optional(),
 	trustWindowDays: z.number().nonnegative().optional(),
 	contextHeadroom: z.number().positive().optional(),
+	reasoningCompletionFloor: z.number().int().nonnegative().optional(),
 	latencyWeight: z.number().nonnegative().optional(),
 	latencyReferenceMs: z.number().positive().optional(),
 	latencyReferenceTokensPerSec: z.number().positive().optional(),

package/src/config/types.ts

@@ -221,6 +221,21 @@ export interface FilterConfig {
 	includeFree: boolean;
 	/** Require `supported_parameters` to include `tools` whenever the request offers tools. */
 	requireToolSupport: boolean;
+	/**
+	 * Smallest completion budget a REASONING model is dispatched with, tokens.
+	 *
+	 * A reasoning model spends the budget thinking before it answers, so a
+	 * caller's tight cap returns nothing at all: omp asks for ~12 tokens for a
+	 * conversation title, and `ollama/gpt-oss:20b` hit the cap having produced
+	 * no content, which cost a dead dispatch and a failover to another model.
+	 * When the chosen model reasons and the caller asked for less than this, the
+	 * dispatch is raised to this floor (never above the model's own completion
+	 * ceiling). Models that answer directly keep the caller's cap.
+	 *
+	 * A cap is an upper bound, not a target — a model that answers in ten tokens
+	 * still stops at ten. 0 disables the floor.
+	 */
+	reasoningCompletionFloor: number;
 	/** Drop models whose ledger success rate is below this, once `minTrustSamples` is met. */
 	minTrust: number;
 	/**

package/src/router/select.ts

@@ -608,6 +608,18 @@ export function select(args: SelectArgs): Decision {
 		// The ceiling is a hard limit anyway; passing it explicitly also caps runaway completions.
 		maxTokens = maxTokens === undefined ? ceiling : Math.min(maxTokens, ceiling);
 	}
+	// A reasoning model spends the budget thinking before it answers, so a caller's
+	// tight cap returns nothing and the turn fails over having paid for the dispatch.
+	// Raise it to the floor for those models only; the ceiling still wins.
+	const floor = cfg.filters.reasoningCompletionFloor;
+	const thinksBeforeAnswering = chosen.model.reasoningMandatory || (chosen.model.supportsReasoning && reasoning !== "off");
+	if (floor > 0 && thinksBeforeAnswering && maxTokens !== undefined && maxTokens < floor) {
+		const raised = ceiling === undefined ? floor : Math.min(floor, ceiling);
+		if (raised > maxTokens) {
+			reasons.push(`completion budget raised ${maxTokens} → ${raised}: ${chosen.model.slug} reasons before it answers`);
+			maxTokens = raised;
+		}
+	}
 	const stripAssistantReasoning = !(chosen.model.supportsReasoning && REASONING_REPLAY_AUTHORS[chosen.model.author] === true);
 
 	// The recorded forecast is the EXPECTED price of this dispatch, not the

package/test/failover.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",

package/test/select.test.ts

@@ -82,9 +82,11 @@ function run(opts: {
 	tier?: Tier;
 	ledger?: Ledger | null;
 	harnessId?: string;
+	maxTokens?: number;
 }) {
 	const cfg = opts.cfg ?? BASE;
-	const req = request(opts.userText ?? "tidy the retry helper");
+	const base = request(opts.userText ?? "tidy the retry helper");
+	const req = opts.maxTokens === undefined ? base : { ...base, maxTokens: opts.maxTokens };
 	const features = extractFeatures(req, opts.promptTokens ?? 4000);
 	const heuristic = scoreHeuristic(features, cfg);
 	const classification = opts.tier === undefined ? heuristic : { ...heuristic, tier: opts.tier };
@@ -353,6 +355,31 @@ describe("decision shape", () => {
 		}
 	});
 
+	test("a reasoning model gets the completion floor; a direct one keeps the caller's cap", () => {
+		const usable = (m: (typeof MODELS)[number]): boolean => m.supportsTools && m.contextLength >= 32_000 && (m.maxCompletionTokens ?? 100_000) >= 4096;
+		const thinker = MODELS.find((m) => usable(m) && m.supportsReasoning);
+		const direct = MODELS.find((m) => usable(m) && !m.supportsReasoning && !m.reasoningMandatory);
+		expect(thinker).toBeDefined();
+		expect(direct).toBeDefined();
+		const withFloor = (slug: string, floor: number): RouterConfig => ({ ...BASE, filters: { ...BASE.filters, allow: [slug], reasoningCompletionFloor: floor } });
+
+		// omp asks for a dozen tokens for a title; a reasoning model would spend them thinking
+		// and return nothing, so the dispatch is raised.
+		const raised = run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 12 });
+		expect(raised.slug).toBe(thinker!.slug);
+		expect(raised.maxTokens).toBe(512);
+		expect(raised.reasons.some((r) => r.includes("reasons before it answers"))).toBe(true);
+
+		// A model that answers directly is untouched: its cap is the caller's.
+		const kept = run({ tier: "trivial", cfg: withFloor(direct!.slug, 512), maxTokens: 12 });
+		expect(kept.slug).toBe(direct!.slug);
+		expect(kept.maxTokens).toBe(12);
+
+		// The floor never raises past what the caller already asked for, and 0 disables it.
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 512), maxTokens: 4000 }).maxTokens).toBe(4000);
+		expect(run({ tier: "trivial", cfg: withFloor(thinker!.slug, 0), maxTokens: 12 }).maxTokens).toBe(12);
+	});
+
 	test("plans a probe for cheap tiers and leaves the top tier unprobed", () => {
 		expect(run({ tier: "trivial" }).probe.enabled).toBe(true);
 		// Nothing above `hard` to escalate into, so probing it would only add latency.

package/test/turn.test.ts

@@ -46,7 +46,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			data: { axis: "intelligence", minQuality: 0 },
 			chat: { axis: "intelligence", minQuality: 0 },
 		},
-		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
+		filters: { allow: [], deny: [], includeFree: false, requireToolSupport: true, minTrust: 0.6, feedbackWeight: 0, feedbackByTask: false, minTrustSamples: 5, trustScopedByHarness: false, trustWindowDays: 0, contextHeadroom: 1.2, reasoningCompletionFloor: 0, latencyWeight: 0, latencyReferenceMs: 5000, latencyReferenceTokensPerSec: 30, cacheReliabilityMinSamples: 10, latencyMinSamples: 20, escalationCostWeight: 0 },
 		classifier: {
 			ambiguityThreshold: 0,
 			model: "test/adjudicator", learnedModelPath: "",