feat(auto-routing): auto-sync decider benchmark models

apps/web/src/app/admin/api/auto-routing/benchmark-config/route.test.ts

@@ -78,6 +78,8 @@ const validConfig = {
   classifierRepetitions: 1,
   deciderRepetitions: 1,
   classifierMaxP95LatencyMs: 1000,
+  autoDeciderMinCostUsd: 15,
+  autoDeciderMaxCostUsd: 25,
   updatedAt: null,
   updatedBy: null,
 };

apps/web/src/app/admin/auto-routing/BenchmarksSection.test.ts

@@ -1,9 +1,11 @@
 import { describe, expect, it } from '@jest/globals';
+import type { BenchmarkConfig } from '@kilocode/auto-routing-contracts';
 import React from 'react';
 import { renderToStaticMarkup } from 'react-dom/server';
 import {
   configToFormState,
   costPerAccuracy,
+  effectiveDeciderModels,
   formatCostPerAccuracy,
   formatAccuracy,
   formatUsd,
@@ -119,18 +121,28 @@ describe('configToFormState', () => {
     expect(state.classifierRepetitions).toBe(1);
     expect(state.deciderRepetitions).toBe(1);
     expect(state.classifierMaxP95LatencyMs).toBe('1000');
+    expect(state.autoDeciderMinCostUsd).toBe(15);
+    expect(state.autoDeciderMaxCostUsd).toBe(25);
     expect(state.classifierModels).toBe('');
     expect(state.deciderModels).toEqual([]);
+    expect(state.autoDeciderModels).toEqual([]);
+    expect(state.excludedAutoDeciderModels).toBe('');
     expect(state.maxConcurrency).toBe(100);
     expect(state.benchmarkUserId).toBe('ce12ef3d-ae95-4d77-b4f0-23735f0a0591');
     expect(state.benchmarkOrgId).toBe('9d278969-5453-4ae3-a51f-a8d2274a7b56');
   });
 });
 
 describe('formStateToConfig round-trip', () => {
-  const baseConfig = {
+  const baseConfig: BenchmarkConfig = {
     classifierModels: ['model-a', 'model-b'],
     deciderModels: [{ id: 'model-c', reasoningEffort: null }],
+    manualDeciderModels: [{ id: 'manual-model', reasoningEffort: 'low' }],
+    autoDeciderModels: [
+      { id: 'auto-model', reasoningEffort: null, avgAttemptCostUsd: 21.25 },
+      { id: 'excluded-auto-model', reasoningEffort: 'high', avgAttemptCostUsd: 18 },
+    ],
+    excludedAutoDeciderModels: ['excluded-auto-model'],
     minAccuracy: 0.8,
     switchCostFactor: 3,
     maxConcurrency: 4,
@@ -139,22 +151,37 @@ describe('formStateToConfig round-trip', () => {
     classifierRepetitions: 3,
     deciderRepetitions: 2,
     classifierMaxP95LatencyMs: 500,
+    autoDeciderMinCostUsd: 12,
+    autoDeciderMaxCostUsd: 24,
     updatedAt: null,
     updatedBy: null,
   };
 
-  it('preserves classifierRepetitions, deciderRepetitions, and classifierMaxP95LatencyMs', () => {
+  it('preserves repetitions, classifierMaxP95LatencyMs, and auto decider cost bounds', () => {
     const state = configToFormState(baseConfig);
     expect(state.classifierRepetitions).toBe(3);
     expect(state.deciderRepetitions).toBe(2);
     expect(state.classifierMaxP95LatencyMs).toBe('500');
+    expect(state.autoDeciderMinCostUsd).toBe(12);
+    expect(state.autoDeciderMaxCostUsd).toBe(24);
     expect(state.benchmarkOrgId).toBe('org-123');
+    expect(state.deciderModels).toEqual([{ id: 'manual-model', reasoningEffort: 'low' }]);
+    expect(state.autoDeciderModels).toEqual(baseConfig.autoDeciderModels);
+    expect(state.excludedAutoDeciderModels).toBe('excluded-auto-model');
 
     const result = formStateToConfig(state, baseConfig);
     expect(result.classifierRepetitions).toBe(3);
     expect(result.deciderRepetitions).toBe(2);
     expect(result.classifierMaxP95LatencyMs).toBe(500);
+    expect(result.autoDeciderMinCostUsd).toBe(12);
+    expect(result.autoDeciderMaxCostUsd).toBe(24);
     expect(result.benchmarkOrgId).toBe('org-123');
+    expect(result.manualDeciderModels).toEqual([{ id: 'manual-model', reasoningEffort: 'low' }]);
+    expect(result.excludedAutoDeciderModels).toEqual(['excluded-auto-model']);
+    expect(result.deciderModels).toEqual([
+      { id: 'manual-model', reasoningEffort: 'low' },
+      { id: 'auto-model', reasoningEffort: null },
+    ]);
   });
 
   it('converts empty-string classifierMaxP95LatencyMs form value to null in config', () => {
@@ -164,3 +191,26 @@ describe('formStateToConfig round-trip', () => {
     expect(result.classifierMaxP95LatencyMs).toBeNull();
   });
 });
+
+describe('effectiveDeciderModels', () => {
+  it('combines manual models with non-excluded auto models and lets manual override an auto duplicate', () => {
+    expect(
+      effectiveDeciderModels({
+        manualDeciderModels: [
+          { id: 'manual/model', reasoningEffort: null },
+          { id: 'auto/duplicate', reasoningEffort: 'high' },
+        ],
+        autoDeciderModels: [
+          { id: 'auto/duplicate', reasoningEffort: null, avgAttemptCostUsd: 20 },
+          { id: 'auto/included', reasoningEffort: 'low', avgAttemptCostUsd: 22 },
+          { id: 'auto/excluded', reasoningEffort: null, avgAttemptCostUsd: 23 },
+        ],
+        excludedAutoDeciderModels: ['auto/excluded'],
+      })
+    ).toEqual([
+      { id: 'manual/model', reasoningEffort: null },
+      { id: 'auto/duplicate', reasoningEffort: 'high' },
+      { id: 'auto/included', reasoningEffort: 'low' },
+    ]);
+  });
+});