auto-model-router 0.2.0 → 0.2.1

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

package/package.json

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

package/src/router/classify.ts

@@ -43,9 +43,18 @@ const W_LARGE_CONTENT = 0.05;
 const W_HUGE_CONTENT = 0.1;
 const W_TURN_DEPTH = 0.004; // long conversations accumulate entangled context
 const CAP_TURN_DEPTH = 0.08;
-const W_LOOP_DEPTH = -0.008; // deep loops are mechanical
+const W_LOOP_DEPTH = -0.008; // a single deep step is mechanical
 const CAP_LOOP_DEPTH = -0.06;
-const W_AUTONOMOUS_LOOP = 0.06; // but a loop this long implies a substantial underlying task
+// A sustained autonomous loop is the signal the underlying task is substantial:
+// the agent keeps grinding without human input. Unlike the mechanical-step
+// penalty above, this term ACCUMULATES with depth past the agentic threshold so
+// long/hard loops climb out of trivial instead of scoring like a one-line edit.
+// Capped so pure depth tops out in `simple` (a competent-but-cheap model);
+// reaching `moderate`/`hard` still requires real complexity signals (tool
+// failure, repeated call, keywords) to stack on top.
+const W_AUTONOMOUS_LOOP = 0.06; // base bonus at the threshold
+const W_AUTONOMOUS_LOOP_PER_DEPTH = 0.018; // added per loop step beyond the threshold
+const CAP_AUTONOMOUS_LOOP = 0.34;
 const W_IMAGES = 0.04;
 const W_TOOLS_OFFERED = 0.03;
 
@@ -100,7 +109,11 @@ export function scoreHeuristic(f: Features, cfg: RouterConfig): Classification {
 	add(Math.min(f.turnDepth * W_TURN_DEPTH, CAP_TURN_DEPTH), `conversation depth ${f.turnDepth}`);
 	add(Math.max(f.toolLoopDepth * W_LOOP_DEPTH, CAP_LOOP_DEPTH), `tool loop depth ${f.toolLoopDepth}`);
 	if (f.toolLoopDepth >= cfg.classifier.agenticLoopDepth && f.toolLoopDepth > 0) {
-		add(W_AUTONOMOUS_LOOP, "long autonomous loop implies a substantial task");
+		const excessDepth = f.toolLoopDepth - cfg.classifier.agenticLoopDepth;
+		add(
+			Math.min(W_AUTONOMOUS_LOOP + excessDepth * W_AUTONOMOUS_LOOP_PER_DEPTH, CAP_AUTONOMOUS_LOOP),
+			`autonomous loop depth ${f.toolLoopDepth} (sustained task)`,
+		);
 	}
 	if (f.hasImages) add(W_IMAGES, "image input");
 	if (f.toolCount > 0) add(W_TOOLS_OFFERED, `${f.toolCount} tools offered`);

package/test/classify.test.ts

@@ -37,6 +37,32 @@ function featuresFor(messages: unknown[], tools?: unknown[] | undefined): Featur
 	return extractFeatures(r, 5000);
 }
 
+/** A tool-result continuation at a given autonomous-loop depth, no other signals. */
+function contFeatures(toolLoopDepth: number, over: Partial<Features> = {}): Features {
+	return {
+		promptTokens: 30000,
+		newContentTokens: 200,
+		turnDepth: toolLoopDepth,
+		toolCount: 12,
+		toolSchemaBytes: 9783,
+		isToolResultContinuation: true,
+		toolLoopDepth,
+		distinctToolsUsed: 3,
+		lastToolFailed: false,
+		repeatedToolCall: false,
+		hasImages: false,
+		codeBlocks: 0,
+		codeBytes: 0,
+		looksLikeDiff: false,
+		complexityKeywords: [],
+		trivialityKeywords: [],
+		requestedReasoning: undefined,
+		questionCount: 0,
+		isTerseInstruction: false,
+		...over,
+	};
+}
+
 const SYSTEM = { role: "system", content: "You are a coding agent." };
 
 /** Upstream double that fails loudly if the adjudicator is consulted. */
@@ -160,6 +186,39 @@ describe("scoreHeuristic", () => {
 		expect(c.confidence).toBeGreaterThanOrEqual(0);
 		expect(c.confidence).toBeLessThanOrEqual(1);
 	});
+
+	test("a shallow tool-result continuation stays trivial", () => {
+		const shallow = scoreHeuristic(contFeatures(2), BASE);
+		expect(shallow.tier).toBe("trivial");
+	});
+
+	test("a sustained autonomous loop climbs out of trivial", () => {
+		// The failure mode this fixes: a long coding loop pinned to the cheapest
+		// tier for dozens of turns because agentic complexity never accumulated.
+		const shallow = scoreHeuristic(contFeatures(2), BASE);
+		const deep = scoreHeuristic(contFeatures(20), BASE);
+		expect(tierIdx(deep.tier)).toBeGreaterThan(tierIdx(shallow.tier));
+		expect(deep.tier).not.toBe("trivial");
+	});
+
+	test("score increases monotonically with loop depth past the agentic threshold", () => {
+		const depths = [4, 6, 8, 10, 15, 20, 30];
+		let prev = -1;
+		for (const d of depths) {
+			const s = scoreHeuristic(contFeatures(d), BASE).score;
+			expect(s).toBeGreaterThanOrEqual(prev);
+			prev = s;
+		}
+	});
+
+	test("pure loop depth tops out at simple; complexity signals stack to moderate", () => {
+		// Depth alone means competent-but-cheap (simple), not a frontier model.
+		const veryDeep = scoreHeuristic(contFeatures(90), BASE);
+		expect(tierIdx(veryDeep.tier)).toBeLessThanOrEqual(tierIdx("simple"));
+		// A failing tool result on top of a deep loop is genuinely hard.
+		const deepAndFailing = scoreHeuristic(contFeatures(20, { lastToolFailed: true }), BASE);
+		expect(tierIdx(deepAndFailing.tier)).toBeGreaterThanOrEqual(tierIdx("moderate"));
+	});
 });
 
 describe("pickQualityAxis", () => {