auto-model-router 0.2.32 → 0.2.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auto-model-router",
-  "version": "0.2.32",
+  "version": "0.2.33",
   "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,7 +118,21 @@ 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.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) add(W_CIRCULAR_LOOP, "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 ?? ""}`);

package/test/classify.test.ts

@@ -269,9 +269,30 @@ describe("scoreHeuristic", () => {
 		expect(deepCircular.tier).toBe("hard");
 	});
 
-	test("a failing tool result on a deep loop is at least moderate", () => {
+	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: {