auto-model-router 0.2.32 → 0.2.34

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.2.32",
+    "version": "0.2.34",
     "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.2.32",
+      "version": "0.2.34",
       "author": {
         "name": "drewappling",
         "email": "drewappling@gmail.com"

package/package.json

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

package/src/config/defaults.ts

@@ -101,8 +101,11 @@ export const DEFAULT_CONFIG: RouterConfig = {
 		toolAxis: "coding",
 		chatAxis: "intelligence",
 		agenticLoopDepth: 3,
-		// Shipped values, unchanged. See ClassifierConfig.reasoningWeights: a
-		// harness that pins the level for a whole session turns these into a
+		// A mechanical retry (failed tool call + tool-result continuation) keeps
+		// only a fifth of the +0.26; a user-visible failure keeps the full weight.
+		mechanicalRetryFactor: 0.2,
+		// Shipped reasoning values, unchanged. See ClassifierConfig.reasoningWeights:
+		// a harness that pins the level for a whole session turns these into a
 		// constant tier offset, in which case `medium` belongs near 0.
 		reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 	},

package/src/config/schema.ts

@@ -86,6 +86,7 @@ const classifier = z.strictObject({
 	toolAxis: qualityAxis.optional(),
 	chatAxis: qualityAxis.optional(),
 	agenticLoopDepth: z.number().int().nonnegative().optional(),
+	mechanicalRetryFactor: z.number().min(0).max(1).optional(),
 	reasoningWeights: z
 		.strictObject({
 			medium: z.number().nonnegative().optional(),

package/src/config/types.ts

@@ -242,6 +242,13 @@ export interface ClassifierConfig {
 	chatAxis: QualityAxis;
 	/** Tool-loop depth above which the agentic axis takes over. */
 	agenticLoopDepth: number;
+	/**
+	 * Fraction of the failed-tool weight that survives when the turn is a
+	 * mechanical tool-result continuation. A retry after a failed tool call is
+	 * the most mechanical turn there is; the flat weight let automated retry
+	 * loops buy the hard tier. 1 preserves the shipped behaviour.
+	 */
+	mechanicalRetryFactor: number;
 	/**
 	 * Score added when the CLIENT asks for a reasoning effort, per level. The
 	 * premise is that asking for reasoning states expected difficulty directly.

package/src/router/classify.ts

@@ -118,8 +118,38 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 		Math.max(f.trivialityKeywords.length * W_TRIVIALITY_KEYWORD, CAP_TRIVIALITY),
 		`triviality keywords [${f.trivialityKeywords.join(", ")}]`,
 	);
-	if (f.lastToolFailed) add(W_TOOL_FAILED, "last tool result failed");
-	if (f.circularToolCall) add(W_CIRCULAR_LOOP, "circular tool call (re-issued a prior call; stuck)");
+	if (f.lastToolFailed) {
+		// A retry after a failed tool call is the MOST mechanical turn there is:
+		// no new user intent, same prompt prefix, the harness just re-asks. The
+		// flat +0.26 let an automated retry loop buy the hard tier ($7.02 of one
+		// measured day vs $0.19 for the same rows as moderate picks). A
+		// continuation keeps only a small nudge; a genuine user-visible failure
+		// (NOT a tool-result continuation) keeps the full weight.
+		const failed = f.isToolResultContinuation ? W_TOOL_FAILED * cfg.classifier.mechanicalRetryFactor : W_TOOL_FAILED;
+		add(
+			failed,
+			f.isToolResultContinuation
+				? `last tool result failed (mechanical retry, damped x${cfg.classifier.mechanicalRetryFactor})`
+				: "last tool result failed",
+		);
+	}
+	if (f.circularToolCall) {
+		// Same logic as the failed-tool clamp above, measured separately: a hard
+		// escalation driven by a circular call NEVER shortened the loop (chains
+		// starting at hard: mean 5.74 turns; chains starting at moderate: mean
+		// 5.74 — identical). The loop ends when the underlying state changes,
+		// not because a pricier model re-read the same tool result. On a
+		// mechanical continuation the circular flag is a stuck retry, not novel
+		// difficulty, so it takes the same damping as the failed-tool bonus;
+		// off a continuation (fresh user turn) it keeps full weight.
+		const circ = f.isToolResultContinuation ? W_CIRCULAR_LOOP * cfg.classifier.mechanicalRetryFactor : W_CIRCULAR_LOOP;
+		add(
+			circ,
+			f.isToolResultContinuation
+				? `circular tool call (mechanical retry, damped x${cfg.classifier.mechanicalRetryFactor})`
+				: "circular tool call (re-issued a prior call; stuck)",
+		);
+	}
 	const rw = reasoningWeight(f.requestedReasoning, cfg);
 	if (rw > 0) add(rw, `client requested reasoning=${f.requestedReasoning ?? ""}`);
 	if (f.isTerseInstruction) add(W_TERSE, "terse instruction");

package/test/classify.test.ts

@@ -263,15 +263,50 @@ describe("scoreHeuristic", () => {
 		expect(scoreHeuristic(contFeatures(400), BASE).tier).toBe("moderate");
 	});
 
-	test("a circular tool call on a deep loop escalates to hard", () => {
-		// The stuck signal raw depth misses: a prior call re-issued verbatim.
-		const deepCircular = scoreHeuristic(contFeatures(90, { circularToolCall: true }), BASE);
+	test("a circular tool call on a FRESH turn escalates to hard", () => {
+		// Off a continuation the stuck signal keeps full weight: the user is
+		// watching a live loop and a pricier model may actually break it.
+		const deepCircular = scoreHeuristic(
+			{ ...contFeatures(90, { circularToolCall: true }), isToolResultContinuation: false },
+			BASE,
+		);
 		expect(deepCircular.tier).toBe("hard");
 	});
 
-	test("a failing tool result on a deep loop is at least moderate", () => {
+	test("a circular tool call on a mechanical continuation is damped, not hard", () => {
+		// Measured: hard escalations on circular calls never shortened the loop
+		// (chain means identical, 5.74 turns, hard vs moderate). 22 of 27 such
+		// hard turns were mechanical continuations paying up to 6x for nothing.
+		const retry = scoreHeuristic(contFeatures(90, { circularToolCall: true }), BASE);
+		const plain = scoreHeuristic(contFeatures(90), BASE);
+		expect(tierIdx(retry.tier)).toBeLessThanOrEqual(tierIdx("moderate"));
+		expect(retry.score).toBeLessThan(plain.score + 0.24);
+	});
+
+	test("a failing tool result on a deep loop is at least simple", () => {
+		// Was 'at least moderate' before the mechanical-retry damp: the flat
+		// +0.26 pushed deep mechanical retry loops into hard. A damped retry
+		// still clears trivial.
 		const deepAndFailing = scoreHeuristic(contFeatures(20, { lastToolFailed: true }), BASE);
-		expect(tierIdx(deepAndFailing.tier)).toBeGreaterThanOrEqual(tierIdx("moderate"));
+		expect(tierIdx(deepAndFailing.tier)).toBeGreaterThanOrEqual(tierIdx("simple"));
+	});
+
+	test("a failed-tool retry on a mechanical continuation is damped, not hard", () => {
+		// A retry after a failed tool call is the most mechanical turn there is;
+		// the flat +0.26 let automated retry loops buy the hard tier ($7.02 of one
+		// measured day vs $0.19 for the same rows as moderate picks). The
+		// continuation keeps only mechanicalRetryFactor of the weight.
+		const retry = scoreHeuristic(contFeatures(20, { lastToolFailed: true }), BASE);
+		const quiet = scoreHeuristic(contFeatures(20), BASE);
+		expect(tierIdx(retry.tier)).toBeLessThan(tierIdx("hard"));
+		expect(retry.score - quiet.score).toBeCloseTo(
+			BASE.classifier.mechanicalRetryFactor * 0.26,
+			5,
+		);
+		// A failure the USER sees (not a tool-result continuation) keeps the full
+		// weight: that genuinely changes what the turn needs.
+		const userSeen = scoreHeuristic(contFeatures(2, { isToolResultContinuation: false, lastToolFailed: true }), BASE);
+		expect(userSeen.score - scoreHeuristic(contFeatures(2, { isToolResultContinuation: false }), BASE).score).toBeCloseTo(0.26, 5);
 	});
 });
 

package/test/failover.test.ts

@@ -55,6 +55,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
+			mechanicalRetryFactor: 0.2,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {

package/test/turn.test.ts

@@ -56,6 +56,7 @@ function mkConfig(escalation: Partial<EscalationConfig> = {}): RouterConfig {
 			toolAxis: "coding",
 			chatAxis: "intelligence",
 			agenticLoopDepth: 3,
+			mechanicalRetryFactor: 0.2,
 			reasoningWeights: { medium: 0.14, high: 0.24, xhigh: 0.3, max: 0.34 },
 		},
 		escalation: {