auto-model-router 0.2.33 → 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.33",
+  "version": "0.2.34",
   "private": false,
   "description": "Local cost/complexity-aware model router for Oh My Pi, backed by OpenRouter",
   "type": "module",

package/src/router/classify.ts

@@ -133,7 +133,23 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 				: "last tool result failed",
 		);
 	}
-	if (f.circularToolCall) add(W_CIRCULAR_LOOP, "circular tool call (re-issued a prior call; stuck)");
+	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,12 +263,26 @@ 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 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